yedra 0.10.8 → 0.11.0

package/dist/index.d.ts

@@ -1,2 +1,5 @@
 import * as y from './lib.js';
 export { y };
+export { App } from './routing/app.js';
+export { Get, Post, Put, Delete } from './routing/rest.js';
+export { Ws } from './routing/websocket.js';

package/dist/index.js

@@ -1,2 +1,5 @@
 import * as y from './lib.js';
 export { y };
+export { App } from './routing/app.js';
+export { Get, Post, Put, Delete } from './routing/rest.js';
+export { Ws } from './routing/websocket.js';

package/dist/lib.d.ts

@@ -1,9 +1,7 @@
 export { HttpError, BadRequestError, UnauthorizedError, PaymentRequiredError, ForbiddenError, NotFoundError, ConflictError, } from './routing/errors.js';
 export { Log } from './routing/log.js';
-export { type Endpoint, app } from './routing/app.js';
 export declare const validatePath: (path: string) => void;
 export { parseEnv } from './routing/env.js';
-export { get, post, put, del, ws } from './routing/endpoints.js';
 export { array } from './validation/array.js';
 export { boolean } from './validation/boolean.js';
 export { date } from './validation/date.js';
@@ -18,7 +16,6 @@ export { BodyType, type Typeof } from './validation/body.js';
 export { raw } from './validation/raw.js';
 export { none } from './validation/none.js';
 export { either } from './validation/either.js';
-export { HttpResponse, HttpRequestError, Http } from './routing/http.js';
 export { string } from './validation/string.js';
 export { _undefined as undefined } from './validation/undefined.js';
 export { union } from './validation/union.js';

package/dist/lib.js

@@ -2,12 +2,10 @@ import { Path } from './routing/path.js';
 // routing
 export { HttpError, BadRequestError, UnauthorizedError, PaymentRequiredError, ForbiddenError, NotFoundError, ConflictError, } from './routing/errors.js';
 export { Log } from './routing/log.js';
-export { app } from './routing/app.js';
 export const validatePath = (path) => {
     new Path(path);
 };
 export { parseEnv } from './routing/env.js';
-export { get, post, put, del, ws } from './routing/endpoints.js';
 // validation
 export { array } from './validation/array.js';
 export { boolean } from './validation/boolean.js';
@@ -23,7 +21,6 @@ export { BodyType } from './validation/body.js';
 export { raw } from './validation/raw.js';
 export { none } from './validation/none.js';
 export { either } from './validation/either.js';
-export { HttpResponse, HttpRequestError, Http } from './routing/http.js';
 export { string } from './validation/string.js';
 export { _undefined as undefined } from './validation/undefined.js';
 export { union } from './validation/union.js';

package/dist/routing/app.d.ts

@@ -1,15 +1,8 @@
-import type { Path } from './path.js';
 import type { Server } from 'bun';
-export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
-export type Endpoint = {
-    method: Method;
-    path: Path;
-    handle: (req: Request, params: Record<string, string>, server: Server) => Promise<Response | undefined>;
-    documentation: () => object;
-};
+import type { Endpoint } from './endpoint.js';
 export declare class App {
-    private endpoints;
-    constructor(endpoints: Endpoint[]);
+    private routes;
+    use(path: string, endpoint: Endpoint): App;
     /**
      * Handle an HTTP request.
      * @param req - The HTTP request.
@@ -35,4 +28,3 @@ export declare class App {
     private static handleWebSocketErrors;
     private matchEndpoint;
 }
-export declare const app: (routes: string) => Promise<App>;

package/dist/routing/app.js

@@ -1,8 +1,12 @@
-import { glob } from 'glob';
 import { HttpError } from './errors.js';
+import { Path } from './path.js';
 export class App {
-    constructor(endpoints) {
-        this.endpoints = endpoints;
+    constructor() {
+        this.routes = [];
+    }
+    use(path, endpoint) {
+        this.routes.push({ path: new Path(path), endpoint });
+        return this;
     }
     /**
      * Handle an HTTP request.
@@ -40,10 +44,11 @@ export class App {
      */
     docs(options) {
         const paths = {};
-        for (const endpoint of this.endpoints) {
-            const path = endpoint.path.toString();
+        for (const route of this.routes) {
+            const path = route.path.toString();
             const methods = paths[path] ?? {};
-            methods[endpoint.method.toLowerCase()] = endpoint.documentation();
+            methods[route.endpoint.method.toLowerCase()] =
+                route.endpoint.documentation();
             paths[path] = methods;
         }
         return {
@@ -105,53 +110,22 @@ export class App {
     matchEndpoint(url, method) {
         let invalidMethod = false;
         let result = undefined;
-        for (const endpoint of this.endpoints) {
-            const match = endpoint.path.match(url);
+        for (const route of this.routes) {
+            const match = route.path.match(url);
             if (match === undefined) {
                 continue;
             }
             const { params, score } = match;
-            if (endpoint.method !== method) {
+            if (route.endpoint.method !== method) {
                 invalidMethod = true;
                 continue;
             }
             const previous = result?.score;
             if (previous === undefined || score < previous) {
                 // if there was no previous match or this one is better, use it
-                result = { endpoint, params, score };
+                result = { endpoint: route.endpoint, params, score };
             }
         }
         return { invalidMethod, result };
     }
 }
-const shouldIgnore = (path) => {
-    const extensions = [
-        '.test.ts',
-        '.schema.ts',
-        '.util.ts',
-        '.d.ts',
-        '.test.js',
-        '.schema.js',
-        '.util.js',
-    ];
-    for (const extension of extensions) {
-        if (path.endsWith(extension)) {
-            return true;
-        }
-    }
-    return false;
-};
-export const app = async (routes) => {
-    const endpoints = [];
-    const files = await glob([`${routes}/**/*.ts`, `${routes}/**/*.js`], {
-        absolute: true,
-    });
-    for (const file of files) {
-        if (shouldIgnore(file)) {
-            continue;
-        }
-        const endpoint = await import(file);
-        endpoints.push(endpoint.default);
-    }
-    return new App(endpoints);
-};

package/dist/routing/endpoint.d.ts

@@ -0,0 +1,6 @@
+import type { Server } from 'bun';
+export interface Endpoint {
+    get method(): 'GET' | 'POST' | 'PUT' | 'DELETE';
+    handle(req: Request, params: Record<string, string>, server: Server): Promise<Response | undefined>;
+    documentation(): object;
+}

package/dist/routing/endpoint.js

@@ -0,0 +1 @@
+export {};

package/dist/routing/rest.d.ts

@@ -0,0 +1,57 @@
+import type { Server } from 'bun';
+import type { BodyType, Typeof } from '../validation/body.js';
+import { type ObjectSchema } from '../validation/object.js';
+import type { Schema } from '../validation/schema.js';
+import type { Endpoint } from './endpoint.js';
+import { NoneBody } from '../validation/none.js';
+type ReqObject<Params, Query, Headers, Body> = {
+    url: string;
+    params: Params;
+    query: Query;
+    headers: Headers;
+    body: Body;
+};
+type ResObject<Body> = Promise<{
+    status?: number;
+    body: Body;
+    headers?: Record<string, string>;
+}> | {
+    status?: number;
+    body: Body;
+    headers?: Record<string, string>;
+};
+type EndpointOptions<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>> = {
+    category: string;
+    summary: string;
+    description?: string;
+    params: Params;
+    query: Query;
+    headers: Headers;
+    req: Req;
+    res: Res;
+    do: (req: ReqObject<Typeof<ObjectSchema<Params>>, Typeof<ObjectSchema<Query>>, Typeof<ObjectSchema<Headers>>, Typeof<Req>>) => ResObject<Typeof<Res>>;
+};
+declare class RestEndpoint<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>> implements Endpoint {
+    private _method;
+    private options;
+    private paramsSchema;
+    private querySchema;
+    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>, _server: Server): Promise<Response | undefined>;
+    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 RestEndpoint<Params, Query, Headers, NoneBody, Res> {
+    constructor(options: Omit<EndpointOptions<Params, Query, Headers, NoneBody, Res>, 'req'>);
+}
+export declare class Post<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<Params, Query, Headers, Req, Res> {
+    constructor(options: EndpointOptions<Params, Query, Headers, Req, Res>);
+}
+export declare class Put<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<Params, Query, Headers, Req, Res> {
+    constructor(options: EndpointOptions<Params, Query, Headers, Req, Res>);
+}
+export declare class Delete<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>, Headers extends Record<string, Schema<unknown>>, Res extends BodyType<unknown>> extends RestEndpoint<Params, Query, Headers, NoneBody, Res> {
+    constructor(options: Omit<EndpointOptions<Params, Query, Headers, NoneBody, Res>, 'req'>);
+}
+export {};

package/dist/routing/rest.js

@@ -0,0 +1,130 @@
+import { object } from '../validation/object.js';
+import { BadRequestError } from './errors.js';
+import { ValidationError } from '../validation/error.js';
+import { none, NoneBody } from '../validation/none.js';
+class RestEndpoint {
+    constructor(method, options) {
+        this._method = method;
+        this.options = options;
+        this.paramsSchema = object(options.params);
+        this.querySchema = object(options.query);
+        this.headersSchema = object(options.headers);
+    }
+    get method() {
+        return this.method;
+    }
+    async handle(req, params, _server) {
+        let parsedBody;
+        let parsedParams;
+        let parsedQuery;
+        let parsedHeaders;
+        const url = new URL(req.url);
+        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));
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new BadRequestError(error.message);
+            }
+            if (error instanceof ValidationError) {
+                throw new BadRequestError(error.format());
+            }
+            throw error;
+        }
+        const response = await this.options.do({
+            url: url.pathname,
+            params: parsedParams,
+            query: parsedQuery,
+            headers: parsedHeaders,
+            body: parsedBody,
+        });
+        if (response.body instanceof Uint8Array) {
+            return new Response(response.body, {
+                status: response.status,
+                headers: response.headers,
+            });
+        }
+        return Response.json(response.body, {
+            status: response.status,
+            headers: response.headers,
+        });
+    }
+    documentation() {
+        const parameters = [
+            ...paramDocs(this.options.params, 'path'),
+            ...paramDocs(this.options.query, 'query'),
+            ...paramDocs(this.options.headers, 'header'),
+        ];
+        return {
+            tags: [this.options.category],
+            summary: this.options.summary,
+            description: this.options.description,
+            parameters,
+            requestBody: {
+                required: this.options.req instanceof NoneBody,
+                content: this.options.req.bodyDocs(),
+            },
+            responses: {
+                '200': {
+                    description: 'Success',
+                    content: this.options.res.bodyDocs(),
+                },
+                '400': {
+                    description: 'Bad Request',
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    status: {
+                                        type: 'number',
+                                    },
+                                    errorMessage: {
+                                        type: 'string',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+}
+export class Get extends RestEndpoint {
+    constructor(options) {
+        super('GET', { req: none(), ...options });
+    }
+}
+export class Post extends RestEndpoint {
+    constructor(options) {
+        super('POST', options);
+    }
+}
+export class Put extends RestEndpoint {
+    constructor(options) {
+        super('PUT', options);
+    }
+}
+export class Delete extends RestEndpoint {
+    constructor(options) {
+        super('DELETE', { req: none(), ...options });
+    }
+}
+const paramDocs = (params, position) => {
+    const result = [];
+    for (const name in params) {
+        const docs = params[name].documentation();
+        result.push({
+            name,
+            in: position,
+            description: 'description' in docs ? docs.description : undefined,
+            required: !params[name].isOptional(),
+            schema: docs,
+        });
+    }
+    return result;
+};

package/dist/routing/websocket.d.ts

@@ -0,0 +1,66 @@
+import type { Server, ServerWebSocket } from 'bun';
+import type { Schema } from '../validation/schema.js';
+import { type ObjectSchema } from '../validation/object.js';
+import type { Typeof } from '../validation/body.js';
+import type { Endpoint } from './endpoint.js';
+type OpenCb = (ws: ServerWebSocket<{
+    handler: WebSocketHandler;
+}>) => Promise<void> | void;
+type MessageCb = (message: Buffer) => Promise<void> | void;
+type CloseCb = (code: number | undefined, reason: string | undefined) => Promise<void> | void;
+export declare class WebSocketHandler {
+    open: OpenCb;
+    messageCbs: MessageCb[];
+    closeCbs: CloseCb[];
+    constructor(open: OpenCb);
+    message(message: Buffer): Promise<void>;
+    close(code: number | undefined, reason: string | undefined): Promise<void>;
+}
+declare class Socket {
+    private handler;
+    private ws;
+    constructor(handler: WebSocketHandler, ws: ServerWebSocket<{
+        handler: WebSocketHandler;
+    }>);
+    set onmessage(cb: MessageCb);
+    set onclose(cb: CloseCb);
+    /**
+     * Send binary data over the WebSocket connection;
+     * @param message - The message buffer that will be sent.
+     */
+    send(message: Buffer): void;
+    /**
+     * Closes the WebSocket.
+     * @param code - The close code. Must be one of:
+     * - 1000: normal closure
+     * - 1009: message too big
+     * - 1011: server encountered error
+     * - 1012: server restarting
+     * - 1013: server too busy or rate-limiting
+     * - 4000-4999: reserved for applications
+     * @param reason - The reason the WebSocket was closed.
+     */
+    close(code?: number, reason?: string): void;
+}
+type WebSocketOptions<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>> = {
+    category: string;
+    summary: string;
+    description?: string;
+    params: Params;
+    query: Query;
+    do: (ws: Socket, req: {
+        url: string;
+        params: Typeof<ObjectSchema<Params>>;
+        query: Typeof<ObjectSchema<Query>>;
+    }) => Promise<void> | void;
+};
+export declare class Ws<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>> implements Endpoint {
+    private options;
+    private paramsSchema;
+    private querySchema;
+    constructor(options: WebSocketOptions<Params, Query>);
+    get method(): 'GET';
+    handle(req: Request, params: Record<string, string>, server: Server): Promise<Response | undefined>;
+    documentation(): object;
+}
+export {};

package/dist/routing/websocket.js

@@ -0,0 +1,101 @@
+import { object } from '../validation/object.js';
+import { BadRequestError } from './errors.js';
+import { ValidationError } from '../validation/error.js';
+export class WebSocketHandler {
+    constructor(open) {
+        this.messageCbs = [];
+        this.closeCbs = [];
+        this.open = open;
+    }
+    async message(message) {
+        for (const cb of this.messageCbs) {
+            await cb(message);
+        }
+    }
+    async close(code, reason) {
+        for (const cb of this.closeCbs) {
+            await cb(code, reason);
+        }
+    }
+}
+class Socket {
+    constructor(handler, ws) {
+        this.handler = handler;
+        this.ws = ws;
+    }
+    set onmessage(cb) {
+        this.handler.messageCbs.push(cb);
+    }
+    set onclose(cb) {
+        this.handler.closeCbs.push(cb);
+    }
+    /**
+     * Send binary data over the WebSocket connection;
+     * @param message - The message buffer that will be sent.
+     */
+    send(message) {
+        this.ws.send(message);
+    }
+    /**
+     * Closes the WebSocket.
+     * @param code - The close code. Must be one of:
+     * - 1000: normal closure
+     * - 1009: message too big
+     * - 1011: server encountered error
+     * - 1012: server restarting
+     * - 1013: server too busy or rate-limiting
+     * - 4000-4999: reserved for applications
+     * @param reason - The reason the WebSocket was closed.
+     */
+    close(code, reason) {
+        this.ws.close(code, reason);
+    }
+}
+export class Ws {
+    constructor(options) {
+        this.options = options;
+        this.paramsSchema = object(options.params);
+        this.querySchema = object(options.query);
+    }
+    get method() {
+        return 'GET';
+    }
+    async handle(req, params, server) {
+        const url = new URL(req.url);
+        if (req.headers.get('upgrade') !== 'websocket') {
+            throw new BadRequestError(`WebSocket required for ${url.pathname}`);
+        }
+        const handler = new WebSocketHandler(async (ws) => {
+            const socket = new Socket(handler, ws);
+            let parsedParams;
+            let parsedQuery;
+            try {
+                parsedParams = this.paramsSchema.parse(params);
+                parsedQuery = this.querySchema.parse(Object.fromEntries(url.searchParams));
+            }
+            catch (error) {
+                if (error instanceof ValidationError) {
+                    throw new BadRequestError(error.format());
+                }
+                throw error;
+            }
+            await this.options.do(socket, {
+                url: url.pathname,
+                params: parsedParams,
+                query: parsedQuery,
+            });
+        });
+        if (!server.upgrade(req, {
+            data: {
+                handler,
+            },
+        })) {
+            throw new BadRequestError('Upgrading to WebSocket failed.');
+        }
+        return undefined;
+    }
+    documentation() {
+        // TODO
+        return {};
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yedra",
-  "version": "0.10.8",
+  "version": "0.11.0",
   "repository": "github:0codekit/yedra",
   "main": "dist/index.js",
   "devDependencies": {
@@ -22,7 +22,6 @@
   "type": "module",
   "dependencies": {
     "@types/uuid": "^10.0.0",
-    "glob": "^11.0.0",
     "uuid": "^10.0.0"
   }
 }

package/dist/routing/endpoints.d.ts

@@ -1,89 +0,0 @@
-import { type BodyType, type Schema, type Typeof } from '../lib.js';
-import { NoneBody } from '../validation/none.js';
-import { type ObjectSchema } from '../validation/object.js';
-import type { Endpoint } from './app.js';
-import type { ServerWebSocket } from 'bun';
-type ReqObject<Params, Query, Headers, Body> = {
-    url: string;
-    params: Params;
-    query: Query;
-    headers: Headers;
-    body: Body;
-};
-type ResObject<Body> = Promise<{
-    status?: number;
-    body: Body;
-    headers?: Record<string, string>;
-}> | {
-    status?: number;
-    body: Body;
-    headers?: Record<string, string>;
-};
-type EndpointOptions<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>> = {
-    category: string;
-    summary: string;
-    description?: string;
-    params: Params;
-    query: Query;
-    headers: Headers;
-    req: Req;
-    res: Res;
-    do: (req: ReqObject<Typeof<ObjectSchema<Params>>, Typeof<ObjectSchema<Query>>, Typeof<ObjectSchema<Headers>>, Typeof<Req>>) => ResObject<Typeof<Res>>;
-};
-export declare const get: <Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>, Headers extends Record<string, Schema<unknown>>, Res extends BodyType<unknown>>(path: string, options: Omit<EndpointOptions<Params, Query, Headers, NoneBody, Res>, "req">) => Endpoint;
-export declare const post: <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>>(path: string, options: EndpointOptions<Params, Query, Headers, Req, Res>) => Endpoint;
-export declare const put: <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>>(path: string, options: EndpointOptions<Params, Query, Headers, Req, Res>) => Endpoint;
-export declare const del: <Path extends string, Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>, Headers extends Record<string, Schema<unknown>>, Res extends BodyType<unknown>>(path: Path, options: Omit<EndpointOptions<Params, Query, Headers, NoneBody, Res>, "req">) => Endpoint;
-type OpenCb = (ws: ServerWebSocket<{
-    handler: WebSocketHandler;
-}>) => Promise<void> | void;
-type MessageCb = (message: Buffer) => Promise<void> | void;
-type CloseCb = (code: number | undefined, reason: string | undefined) => Promise<void> | void;
-export declare class WebSocketHandler {
-    open: OpenCb;
-    messageCbs: MessageCb[];
-    closeCbs: CloseCb[];
-    constructor(open: OpenCb);
-    message(message: Buffer): Promise<void>;
-    close(code: number | undefined, reason: string | undefined): Promise<void>;
-}
-declare class Socket {
-    private handler;
-    private ws;
-    constructor(handler: WebSocketHandler, ws: ServerWebSocket<{
-        handler: WebSocketHandler;
-    }>);
-    set onmessage(cb: MessageCb);
-    set onclose(cb: CloseCb);
-    /**
-     * Send binary data over the WebSocket connection;
-     * @param message - The message buffer that will be sent.
-     */
-    send(message: Buffer): void;
-    /**
-     * Closes the WebSocket.
-     * @param code - The close code. Must be one of:
-     * - 1000: normal closure
-     * - 1009: message too big
-     * - 1011: server encountered error
-     * - 1012: server restarting
-     * - 1013: server too busy or rate-limiting
-     * - 4000-4999: reserved for applications
-     * @param reason - The reason the WebSocket was closed.
-     */
-    close(code?: number, reason?: string): void;
-}
-type WebSocketOptions<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>> = {
-    category: string;
-    summary: string;
-    description?: string;
-    params: Params;
-    query: Query;
-    do: (ws: Socket, req: {
-        url: string;
-        params: Typeof<ObjectSchema<Params>>;
-        query: Typeof<ObjectSchema<Query>>;
-    }) => Promise<void> | void;
-};
-export declare const ws: <Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>>(path: string, options: WebSocketOptions<Params, Query>) => Endpoint;
-export {};

package/dist/routing/endpoints.js

@@ -1,208 +0,0 @@
-import { isUint8Array } from 'node:util/types';
-import { BadRequestError, ValidationError, } from '../lib.js';
-import { none, NoneBody } from '../validation/none.js';
-import { object } from '../validation/object.js';
-import { Path } from './path.js';
-const create = (method, path, options) => {
-    const paramsSchema = object(options.params);
-    const querySchema = object(options.query);
-    const headersSchema = object(options.headers);
-    return {
-        method,
-        path: new Path(path),
-        async handle(req, params) {
-            let parsedBody;
-            let parsedParams;
-            let parsedQuery;
-            let parsedHeaders;
-            const url = new URL(req.url);
-            try {
-                parsedBody = options.req.deserialize(Buffer.from(await req.arrayBuffer()), req.headers.get('content-type') ?? 'application/octet-stream');
-                parsedParams = paramsSchema.parse(params);
-                parsedQuery = querySchema.parse(Object.fromEntries(url.searchParams));
-                parsedHeaders = headersSchema.parse(Object.fromEntries(req.headers));
-            }
-            catch (error) {
-                if (error instanceof SyntaxError) {
-                    throw new BadRequestError(error.message);
-                }
-                if (error instanceof ValidationError) {
-                    throw new BadRequestError(error.format());
-                }
-                throw error;
-            }
-            const response = await options.do({
-                url: url.pathname,
-                params: parsedParams,
-                query: parsedQuery,
-                headers: parsedHeaders,
-                body: parsedBody,
-            });
-            if (isUint8Array(response.body)) {
-                return new Response(response.body, {
-                    status: response.status,
-                    headers: response.headers,
-                });
-            }
-            return Response.json(response.body, {
-                status: response.status,
-                headers: response.headers,
-            });
-        },
-        documentation() {
-            const parameters = [
-                ...paramDocs(options.params, 'path'),
-                ...paramDocs(options.query, 'query'),
-                ...paramDocs(options.headers, 'header'),
-            ];
-            return {
-                tags: [options.category],
-                summary: options.summary,
-                description: options.description,
-                parameters,
-                requestBody: {
-                    required: options.req instanceof NoneBody,
-                    content: options.req.bodyDocs(),
-                },
-                responses: {
-                    '200': {
-                        description: 'Success',
-                        content: options.res.bodyDocs(),
-                    },
-                    '400': {
-                        description: 'Bad Request',
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    type: 'object',
-                                    properties: {
-                                        status: {
-                                            type: 'number',
-                                        },
-                                        errorMessage: {
-                                            type: 'string',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-        },
-    };
-};
-const paramDocs = (params, position) => {
-    const result = [];
-    for (const name in params) {
-        const docs = params[name].documentation();
-        result.push({
-            name,
-            in: position,
-            description: 'description' in docs ? docs.description : undefined,
-            required: !params[name].isOptional(),
-            schema: docs,
-        });
-    }
-    return result;
-};
-export const get = (path, options) => create('GET', path, { ...options, req: none() });
-export const post = (path, options) => create('POST', path, options);
-export const put = (path, options) => create('PUT', path, options);
-export const del = (path, options) => create('DELETE', path, { ...options, req: none() });
-export class WebSocketHandler {
-    constructor(open) {
-        this.messageCbs = [];
-        this.closeCbs = [];
-        this.open = open;
-    }
-    async message(message) {
-        for (const cb of this.messageCbs) {
-            await cb(message);
-        }
-    }
-    async close(code, reason) {
-        for (const cb of this.closeCbs) {
-            await cb(code, reason);
-        }
-    }
-}
-class Socket {
-    constructor(handler, ws) {
-        this.handler = handler;
-        this.ws = ws;
-    }
-    set onmessage(cb) {
-        this.handler.messageCbs.push(cb);
-    }
-    set onclose(cb) {
-        this.handler.closeCbs.push(cb);
-    }
-    /**
-     * Send binary data over the WebSocket connection;
-     * @param message - The message buffer that will be sent.
-     */
-    send(message) {
-        this.ws.send(message);
-    }
-    /**
-     * Closes the WebSocket.
-     * @param code - The close code. Must be one of:
-     * - 1000: normal closure
-     * - 1009: message too big
-     * - 1011: server encountered error
-     * - 1012: server restarting
-     * - 1013: server too busy or rate-limiting
-     * - 4000-4999: reserved for applications
-     * @param reason - The reason the WebSocket was closed.
-     */
-    close(code, reason) {
-        this.ws.close(code, reason);
-    }
-}
-export const ws = (path, options) => {
-    const paramsSchema = object(options.params);
-    const querySchema = object(options.query);
-    return {
-        method: 'GET',
-        path: new Path(path),
-        async handle(req, params, server) {
-            const url = new URL(req.url);
-            if (req.headers.get('upgrade') !== 'websocket') {
-                throw new BadRequestError(`WebSocket required for ${url.pathname}`);
-            }
-            const handler = new WebSocketHandler(async (ws) => {
-                const socket = new Socket(handler, ws);
-                let parsedParams;
-                let parsedQuery;
-                try {
-                    parsedParams = paramsSchema.parse(params);
-                    parsedQuery = querySchema.parse(Object.fromEntries(url.searchParams));
-                }
-                catch (error) {
-                    if (error instanceof ValidationError) {
-                        throw new BadRequestError(error.format());
-                    }
-                    throw error;
-                }
-                await options.do(socket, {
-                    url: url.pathname,
-                    params: parsedParams,
-                    query: parsedQuery,
-                });
-            });
-            if (!server.upgrade(req, {
-                data: {
-                    handler,
-                },
-            })) {
-                throw new BadRequestError('Upgrading to WebSocket failed.');
-            }
-            return undefined;
-        },
-        documentation() {
-            // TODO
-            return {};
-        },
-    };
-};

package/dist/routing/http.d.ts

@@ -1,83 +0,0 @@
-import type { Log, Schema, Typeof } from '../lib.js';
-/**
- * Indicates that the HTTP request failed. This can be
- * due to a network error or a response that indicates
- * failure. In the latter case, the response is part of
- * this error.
- */
-export declare class HttpRequestError extends Error {
-    readonly response?: HttpResponse;
-    constructor(message: string, response?: HttpResponse);
-}
-/**
- * The response to an HTTP request.
- */
-export declare class HttpResponse {
-    /**
-     * The HTTP status code.
-     */
-    readonly status: number;
-    /**
-     * The response headers.
-     */
-    readonly headers: Record<string, string>;
-    /**
-     * The raw response body.
-     */
-    private readonly response;
-    /**
-     * Creates a new HTTP response.
-     * @param status - The status code.
-     * @param headers - The response headers.
-     * @param response - The raw response data.
-     */
-    constructor(status: number, headers: Record<string, string>, response: Uint8Array);
-    /**
-     * @returns The raw response data.
-     */
-    buffer(): Buffer;
-    /**
-     * @returns The response as a UTF-8 encoded string.
-     */
-    text(): string;
-    /**
-     * Parses the response as JSON and according to the
-     * specified schema.
-     * @param schema - The schema. Default is y.unknown().
-     * @returns A JavaScript object.
-     */
-    json<T extends Schema<unknown>>(schema?: T): Typeof<T>;
-}
-/**
- * A class for performing HTTP requests.
- */
-export declare class Http {
-    private log;
-    constructor(log: Log);
-    /**
-     * Performs an HTTP GET request on the given URL.
-     * @param url - The URL.
-     * @param headers - The HTTP headers.
-     * @returns The response.
-     */
-    get(url: string, headers?: Record<string, string>): Promise<HttpResponse>;
-    /**
-     * Performs an HTTP POST request on the given URL. The body is converted
-     * to JSON.
-     * @param url - The URL.
-     * @param body - The body.
-     * @param headers - The HTTP headers.
-     * @returns The response.
-     */
-    post(url: string, body: unknown, headers?: Record<string, string>): Promise<HttpResponse>;
-    /**
-     * Performs an HTTP request on the given URL. The body is converted to JSON.
-     * @param method - The HTTP method.
-     * @param url - The URL.
-     * @param body - The body.
-     * @param headers - The HTTP headers.
-     * @returns The response.
-     */
-    request(method: 'GET' | 'POST', url: string, body: unknown, headers?: Record<string, string>): Promise<HttpResponse>;
-    private getResponse;
-}

package/dist/routing/http.js

@@ -1,123 +0,0 @@
-import { isUint8Array } from 'node:util/types';
-/**
- * Indicates that the HTTP request failed. This can be
- * due to a network error or a response that indicates
- * failure. In the latter case, the response is part of
- * this error.
- */
-export class HttpRequestError extends Error {
-    constructor(message, response) {
-        super(message);
-        this.response = response;
-    }
-}
-/**
- * The response to an HTTP request.
- */
-export class HttpResponse {
-    /**
-     * Creates a new HTTP response.
-     * @param status - The status code.
-     * @param headers - The response headers.
-     * @param response - The raw response data.
-     */
-    constructor(status, headers, response) {
-        this.status = status;
-        this.headers = headers;
-        this.response = Buffer.from(response);
-    }
-    /**
-     * @returns The raw response data.
-     */
-    buffer() {
-        return this.response;
-    }
-    /**
-     * @returns The response as a UTF-8 encoded string.
-     */
-    text() {
-        return this.response.toString('utf8');
-    }
-    /**
-     * Parses the response as JSON and according to the
-     * specified schema.
-     * @param schema - The schema. Default is y.unknown().
-     * @returns A JavaScript object.
-     */
-    json(schema) {
-        const parsed = JSON.parse(this.text());
-        if (schema) {
-            return schema.parse(parsed);
-        }
-        return parsed;
-    }
-}
-/**
- * A class for performing HTTP requests.
- */
-export class Http {
-    constructor(log) {
-        this.log = log;
-    }
-    /**
-     * Performs an HTTP GET request on the given URL.
-     * @param url - The URL.
-     * @param headers - The HTTP headers.
-     * @returns The response.
-     */
-    get(url, headers) {
-        return this.request('GET', url, undefined, headers);
-    }
-    /**
-     * Performs an HTTP POST request on the given URL. The body is converted
-     * to JSON.
-     * @param url - The URL.
-     * @param body - The body.
-     * @param headers - The HTTP headers.
-     * @returns The response.
-     */
-    post(url, body, headers) {
-        return this.request('POST', url, body, headers);
-    }
-    /**
-     * Performs an HTTP request on the given URL. The body is converted to JSON.
-     * @param method - The HTTP method.
-     * @param url - The URL.
-     * @param body - The body.
-     * @param headers - The HTTP headers.
-     * @returns The response.
-     */
-    async request(method, url, body, headers) {
-        const isBuffer = isUint8Array(body);
-        const requestBody = isBuffer ? body : JSON.stringify(body);
-        const actualHeaders = isBuffer
-            ? headers
-            : { 'content-type': 'application/json', ...headers };
-        const response = await this.getResponse(method, url, requestBody, actualHeaders);
-        if (response.status < 200 || response.status >= 300) {
-            throw new HttpRequestError(`HTTP request returned status code ${response.status}`, response);
-        }
-        return response;
-    }
-    async getResponse(method, url, body, headers) {
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                body,
-            });
-            const buffer = Buffer.from(await response.arrayBuffer());
-            const responseHeaders = {};
-            response.headers.forEach((value, key) => {
-                responseHeaders[key] = value;
-            });
-            return new HttpResponse(response.status, responseHeaders, buffer);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new HttpRequestError(error.message);
-            }
-            throw error;
-        }
-    }
-}