bxo 0.0.5-dev.7 → 0.0.5-dev.70

package/src/index.ts

@@ -0,0 +1,644 @@
+import { z } from "zod";
+
+
+type Method =
+    | "GET"
+    | "POST"
+    | "PUT"
+    | "PATCH"
+    | "DELETE"
+    | "OPTIONS"
+    | "HEAD";
+
+type PickWildcardName<S extends string> = S extends "" ? "wildcard" : S;
+
+type PathParams<S extends string> =
+    S extends `${string}*${infer W}`
+    ? { [K in PickWildcardName<W>]: string }
+    : S extends `${string}:${infer P}/${infer R}`
+    ? ({ [K in P]: string } & PathParams<`/${R}`>)
+    : S extends `${string}:${infer P}`
+    ? { [K in P]: string }
+    : {};
+
+type InferOr<T, Fallback> = T extends z.ZodTypeAny ? z.infer<T> : Fallback;
+
+type ResponseSchemas = Record<number, z.ZodTypeAny>;
+
+type InferResponse<S extends RouteSchema | undefined, Status extends number> =
+    S extends RouteSchema
+    ? S["response"] extends Record<Status, z.ZodTypeAny>
+    ? z.infer<S["response"][Status]>
+    : unknown
+    : unknown;
+
+export type RouteSchema = {
+    headers?: z.ZodTypeAny;
+    query?: z.ZodTypeAny;
+    cookies?: z.ZodTypeAny;
+    body?: z.ZodTypeAny;
+    response?: ResponseSchemas;
+    detail?: {
+        defaultContentType?: "multipart/form-data" | "application/json" | "application/x-www-form-urlencoded" | "text/plain" | "application/octet-stream";
+        description?: string;
+        hidden?: boolean;
+        summary?: string;
+        tags?: string[];
+        [k: string]: any;
+    }
+};
+
+type QueryObject = Record<string, string | string[]>;
+type CookieObject = Record<string, string>;
+type HeaderObject = Record<string, string>;
+
+// Lifecycle hook types
+export type BeforeRequestHook = (req: Request, ctx?: Partial<Context<any, any>>) => Request | Response | Promise<Request | Response | void>;
+export type AfterRequestHook = (req: Request, res: Response, ctx?: Partial<Context<any, any>>) => Response | Promise<Response | void>;
+export type BeforeResponseHook = (res: Response, ctx?: Partial<Context<any, any>>) => Response | Promise<Response | void>;
+export type OnErrorHook = (error: Error, req: Request, ctx?: Partial<Context<any, any>>) => Response | Promise<Response | void>;
+
+export type Context<P extends string = string, S extends RouteSchema | undefined = undefined> = {
+    request: Request;
+    params: PathParams<P>;
+    query: S extends RouteSchema ? InferOr<S["query"], QueryObject> : QueryObject;
+    headers: S extends RouteSchema ? InferOr<S["headers"], HeaderObject> : HeaderObject;
+    cookies: S extends RouteSchema ? InferOr<S["cookies"], CookieObject> : CookieObject;
+    body: S extends RouteSchema ? InferOr<S["body"], unknown> : unknown;
+    set: { headers: Record<string, string> };
+    json: <T>(data: T, status?: number) => Response;
+    text: (data: string, status?: number) => Response;
+    status: <T extends number>(status: T, data: InferResponse<S, T>) => Response;
+};
+
+type AnyHandler = (ctx: Context<any, any>, app: BXO) => Response | string | Promise<Response | string>;
+type Handler<P extends string, S extends RouteSchema | undefined = undefined> = (
+    ctx: Context<P, S>,
+    app: BXO
+) => Response | string | Promise<Response | string>;
+
+type InternalRoute = {
+    method: Method | "DEFAULT";
+    path: string;
+    matcher: RegExp | null;
+    paramNames: string[];
+    schema?: RouteSchema;
+    handler: AnyHandler;
+};
+
+type ServeOptions = Partial<Parameters<typeof Bun.serve>[0]>;
+
+function toHeaderObject(headers: Headers): HeaderObject {
+    const obj: HeaderObject = {};
+    headers.forEach((value, key) => {
+        obj[key.toLowerCase()] = value;
+    });
+    return obj;
+}
+
+function parseCookies(cookieHeader: string | null): CookieObject {
+    const out: CookieObject = {};
+    if (!cookieHeader) return out;
+    const parts = cookieHeader.split(";");
+    for (const part of parts) {
+        const [k, ...rest] = part.trim().split("=");
+        if (!k) continue;
+        out[k] = decodeURIComponent(rest.join("="));
+    }
+    return out;
+}
+
+function parseQuery(searchParams: URLSearchParams): QueryObject;
+function parseQuery<T extends z.ZodTypeAny>(searchParams: URLSearchParams, schema: T): z.infer<T>;
+function parseQuery(searchParams: URLSearchParams, schema?: z.ZodTypeAny): any {
+    const out: QueryObject = {};
+    for (const [k, v] of searchParams.entries()) {
+        if (k in out) {
+            const existing = out[k];
+            if (Array.isArray(existing)) out[k] = [...existing, v];
+            else out[k] = [existing as string, v];
+        } else out[k] = v;
+    }
+    if (schema) {
+        return (schema as any).parse ? (schema as any).parse(out) : out;
+    }
+    return out;
+}
+
+function formDataToObject(fd: FormData): Record<string, any> {
+    const obj: Record<string, any> = {};
+    for (const [key, value] of fd.entries()) {
+        if (key in obj) {
+            const existing = obj[key];
+            if (Array.isArray(existing)) obj[key] = [...existing, value];
+            else obj[key] = [existing, value];
+        } else obj[key] = value;
+    }
+    return obj;
+}
+
+function buildMatcher(path: string): { regex: RegExp | null; names: string[] } {
+    if (!path.includes(":") && !path.includes("*")) return { regex: null, names: [] };
+    const names: string[] = [];
+    const pattern = path
+        .split("/")
+        .map((seg, idx, arr) => {
+            if (!seg) return "";
+            if (seg.startsWith(":")) {
+                names.push(seg.slice(1));
+                return "([^/]+)";
+            }
+            if (seg.startsWith("*")) {
+                const name = seg.slice(1) || "wildcard";
+                names.push(name);
+                // wildcard must be terminal
+                return idx === arr.length - 1 ? "(.*)" : "(.*)";
+            }
+            return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        })
+        .join("/");
+    const regex = new RegExp(`^${pattern}$`);
+    return { regex, names };
+}
+
+function mergeHeaders(base: HeadersInit | undefined, extra: Record<string, string>): Headers {
+    const h = new Headers(base);
+    for (const [k, v] of Object.entries(extra)) h.set(k, v);
+    return h;
+}
+
+function toResponse(body: unknown, init?: ResponseInit): Response {
+    if (body instanceof Response) return new Response(body.body, { headers: mergeHeaders(body.headers, {}), status: body.status, statusText: body.statusText });
+    if (
+        typeof body === "string" ||
+        body instanceof Uint8Array ||
+        body instanceof ArrayBuffer ||
+        body instanceof Blob ||
+        body instanceof ReadableStream
+    ) {
+        return new Response(body as BodyInit, init);
+    }
+    // Fallback: stringify unknown values
+    return new Response(String(body), init);
+}
+
+export default class BXO {
+    private routes: InternalRoute[] = [];
+    private serveOptions: ServeOptions;
+    public server?: ReturnType<typeof Bun.serve>;
+
+    // Lifecycle hooks
+    protected beforeRequestHooks: BeforeRequestHook[] = [];
+    protected afterRequestHooks: AfterRequestHook[] = [];
+    protected beforeResponseHooks: BeforeResponseHook[] = [];
+    protected onErrorHooks: OnErrorHook[] = [];
+
+    constructor(options?: { serve?: ServeOptions }) {
+        this.serveOptions = options?.serve ?? {};
+    }
+
+    getRoutes(): InternalRoute[] {
+        return this.routes;
+    }
+
+    getBXO(): this {
+        return this;
+    }
+
+    use(plugin: BXO): this {
+        // Merge routes from another BXO instance
+        this.routes.push(...plugin.routes);
+
+        // Merge lifecycle hooks from plugin
+        this.beforeRequestHooks.push(...plugin.beforeRequestHooks);
+        this.afterRequestHooks.push(...plugin.afterRequestHooks);
+        this.beforeResponseHooks.push(...plugin.beforeResponseHooks);
+        this.onErrorHooks.push(...plugin.onErrorHooks);
+
+        return this;
+    }
+
+    get<P extends string>(path: P, handler: Handler<P, undefined>): this;
+    get<P extends string, S extends RouteSchema>(path: P, handler: Handler<P, S>, schema: S): this;
+    get<P extends string, S extends RouteSchema | undefined>(path: P, handler: Handler<P, S>, schema?: S): this {
+        return this.add("GET", path, handler as AnyHandler, schema as RouteSchema | undefined);
+    }
+
+    post<P extends string>(path: P, handler: Handler<P, undefined>): this;
+    post<P extends string, S extends RouteSchema>(path: P, handler: Handler<P, S>, schema: S): this;
+    post<P extends string, S extends RouteSchema | undefined>(path: P, handler: Handler<P, S>, schema?: S): this {
+        return this.add("POST", path, handler as AnyHandler, schema as RouteSchema | undefined);
+    }
+
+    put<P extends string>(path: P, handler: Handler<P, undefined>): this;
+    put<P extends string, S extends RouteSchema>(path: P, handler: Handler<P, S>, schema: S): this;
+    put<P extends string, S extends RouteSchema | undefined>(path: P, handler: Handler<P, S>, schema?: S): this {
+        return this.add("PUT", path, handler as AnyHandler, schema as RouteSchema | undefined);
+    }
+
+    patch<P extends string>(path: P, handler: Handler<P, undefined>): this;
+    patch<P extends string, S extends RouteSchema>(path: P, handler: Handler<P, S>, schema: S): this;
+    patch<P extends string, S extends RouteSchema | undefined>(path: P, handler: Handler<P, S>, schema?: S): this {
+        return this.add("PATCH", path, handler as AnyHandler, schema as RouteSchema | undefined);
+    }
+
+    delete<P extends string>(path: P, handler: Handler<P, undefined>): this;
+    delete<P extends string, S extends RouteSchema>(path: P, handler: Handler<P, S>, schema: S): this;
+    delete<P extends string, S extends RouteSchema | undefined>(path: P, handler: Handler<P, S>, schema?: S): this {
+        return this.add("DELETE", path, handler as AnyHandler, schema as RouteSchema | undefined);
+    }
+
+    // default can accept a handler OR static content (including Bun HTML bundle)
+    default<P extends string>(path: P, handler: Handler<P, undefined>): this;
+    default<P extends string, S extends RouteSchema>(path: P, handler: (req: Request) => Response, schema: S): this;
+    default<P extends string>(path: P, content: Bun.HTMLBundle): this;
+    default<P extends string, S extends RouteSchema | undefined>(path: P, arg2: unknown, schema?: S): this {
+        return this.add("DEFAULT", path, arg2 as AnyHandler, schema as RouteSchema | undefined);
+    }
+
+    start(): void {
+        // Build a basic routes map for Bun's native routes (exact paths only)
+        const nativeRoutes: Record<string, Record<string, (req: Request) => Promise<Response> | Response>> = {};
+
+        for (const r of this.routes) {
+            switch (r.method) {
+                case "DEFAULT":
+                    nativeRoutes[r.path] = r.handler as any;
+                    break;
+                default:
+                    nativeRoutes[r.path] ||= {} as Record<string, (req: Request) => Promise<Response> | Response>;
+                    nativeRoutes[r.path][r.method] = (req: Request) => this.dispatch(r, req);
+                    break;
+            }
+        }
+
+        this.server = Bun.serve({
+            ...this.serveOptions,
+            routes: nativeRoutes as any,
+            fetch: (req: Request) => this.dispatchAny(req, nativeRoutes)
+        });
+        const port = (this.server as any).port ?? this.serveOptions.port ?? 3000;
+    }
+
+    // Lifecycle hook methods
+    beforeRequest(hook: BeforeRequestHook): this {
+        this.beforeRequestHooks.push(hook);
+        return this;
+    }
+
+    afterRequest(hook: AfterRequestHook): this {
+        this.afterRequestHooks.push(hook);
+        return this;
+    }
+
+    beforeResponse(hook: BeforeResponseHook): this {
+        this.beforeResponseHooks.push(hook);
+        return this;
+    }
+
+    onError(hook: OnErrorHook): this {
+        this.onErrorHooks.push(hook);
+        return this;
+    }
+
+    // Internal
+    private add(method: Method | "DEFAULT", path: string, handler: AnyHandler, schema?: RouteSchema): this {
+        const { regex, names } = buildMatcher(path);
+        this.routes.push({ method, path, handler, matcher: regex, paramNames: names, schema });
+        return this;
+    }
+
+    private async dispatch(route: InternalRoute, req: Request): Promise<Response> {
+        // Run beforeRequest hooks
+        for (const hook of this.beforeRequestHooks) {
+            try {
+                const result = await hook(req);
+                if (result instanceof Response) {
+                    return result;
+                }
+                if (result instanceof Request) {
+                    req = result;
+                }
+            } catch (error) {
+                // Run error hooks
+                for (const errorHook of this.onErrorHooks) {
+                    try {
+                        const errorResponse = await errorHook(error as Error, req);
+                        if (errorResponse instanceof Response) {
+                            return errorResponse;
+                        }
+                    } catch {
+                        // Ignore errors in error hooks
+                    }
+                }
+                return new Response("Internal Server Error", { status: 500 });
+            }
+        }
+
+        const url = new URL(req.url);
+        const params = this.extractParams(route, url.pathname);
+        let queryObj: any;
+        let bodyObj: any = undefined;
+        const cookieObj = parseCookies(req.headers.get("cookie"));
+        const headerObj = toHeaderObject(req.headers);
+
+        // Parse query using schema if provided
+        try {
+            queryObj = route.schema?.query ? parseQuery(url.searchParams, route.schema.query as any) : parseQuery(url.searchParams);
+        } catch (err: any) {
+            const payload = err?.issues ? { error: "Validation Error", issues: err.issues } : { error: "Validation Error" };
+            return new Response(JSON.stringify(payload), { status: 400, headers: { "Content-Type": "application/json" } });
+        }
+
+        // Parse body (best-effort) and validate with schema if provided
+        try {
+            const contentType = req.headers.get("content-type") || "";
+            if (contentType.includes("application/json")) {
+                const raw = await req.json();
+                bodyObj = route.schema?.body ? (route.schema.body as any).parse(raw) : raw;
+            } else if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+                const fd = await req.formData();
+                const raw = formDataToObject(fd);
+                bodyObj = route.schema?.body ? (route.schema.body as any).parse(raw) : raw;
+            } else if (contentType.includes("text/")) {
+                const raw = await req.text();
+                bodyObj = route.schema?.body ? (route.schema.body as any).parse(raw) : raw;
+            } else if (contentType) {
+                // Unknown content-type: provide ArrayBuffer
+                const raw = await req.arrayBuffer();
+                bodyObj = route.schema?.body ? (route.schema.body as any).parse(raw) : raw;
+            } else {
+                // No content-type: try JSON then text, otherwise undefined
+                try {
+                    const raw = await req.json();
+                    bodyObj = route.schema?.body ? (route.schema.body as any).parse(raw) : raw;
+                } catch {
+                    try {
+                        const raw = await req.text();
+                        bodyObj = route.schema?.body ? (route.schema.body as any).parse(raw) : raw;
+                    } catch {
+                        bodyObj = undefined;
+                    }
+                }
+            }
+            if (!bodyObj && route.schema?.body) {
+                return new Response(JSON.stringify({ error: "Body is required" }), { status: 400, headers: { "Content-Type": "application/json" } });
+            }
+        } catch (err: any) {
+            const payload = err?.issues ? { error: "Validation Error", issues: err.issues } : { error: "Validation Error" };
+            return new Response(JSON.stringify(payload), { status: 400, headers: { "Content-Type": "application/json" } });
+        }
+
+
+
+        // Prepare ctx with lazy helpers and header merging
+        const ctx: Context<any, any> = {
+            request: req,
+            params,
+            query: queryObj,
+            headers: headerObj,
+            cookies: cookieObj,
+            body: bodyObj,
+            set: { headers: {} },
+            json: (data, status = 200) => {
+                // Response validation if declared
+                if (route.schema?.response?.[status]) {
+                    const sch = route.schema.response[status]!;
+                    const res = (sch as any).safeParse ? (sch as any).safeParse(data) : { success: true };
+                    if (!res.success) {
+                        return new Response(JSON.stringify({ error: "Invalid response", issues: res.error?.issues ?? [] }), { status: 500, headers: { "Content-Type": "application/json" } });
+                    }
+                }
+                const headers = mergeHeaders({ "Content-Type": "application/json" }, ctx.set.headers);
+                return new Response(JSON.stringify(data), { status, headers });
+            },
+            text: (data, status = 200) => {
+                if (route.schema?.response?.[status]) {
+                    const sch = route.schema.response[status]!;
+                    const res = (sch as any).safeParse ? (sch as any).safeParse(data) : { success: true };
+                    if (!res.success) {
+                        return new Response(JSON.stringify({ error: "Invalid response", issues: res.error?.issues ?? [] }), { status: 500, headers: { "Content-Type": "application/json" } });
+                    }
+                }
+                const headers = mergeHeaders({ "Content-Type": "text/plain" }, ctx.set.headers);
+                return new Response(String(data), { status, headers });
+            },
+            status: (status, data) => {
+                // Response validation if declared
+                if (route.schema?.response?.[status]) {
+                    const sch = route.schema.response[status]!;
+                    const res = (sch as any).safeParse ? (sch as any).safeParse(data) : { success: true };
+                    if (!res.success) {
+                        return new Response(JSON.stringify({ error: "Invalid response", issues: res.error?.issues ?? [] }), { status: 500, headers: { "Content-Type": "application/json" } });
+                    }
+                }
+
+                const resp = toResponse(data, { status });
+                // Merge ctx.set.headers into final response
+                const merged = new Response(resp.body, {
+                    status: resp.status,
+                    statusText: resp.statusText,
+                    headers: mergeHeaders(resp.headers, ctx.set.headers)
+                });
+                return merged;
+            }
+        };
+
+        // Validation
+        if (route.schema) {
+            try {
+                if (route.schema.headers) {
+                    (route.schema.headers as any).parse(headerObj);
+                }
+                if (route.schema.cookies) {
+                    (route.schema.cookies as any).parse(cookieObj);
+                }
+            } catch (err: any) {
+                const payload = err?.issues ? { error: "Validation Error", issues: err.issues } : { error: "Validation Error" };
+                return new Response(JSON.stringify(payload), { status: 400, headers: { "Content-Type": "application/json" } });
+            }
+        }
+
+        const result = await route.handler(ctx, this);
+        const resp = toResponse(result);
+        // Merge ctx.set.headers into final response
+        let merged = new Response(resp.body, {
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: mergeHeaders(resp.headers, ctx.set.headers)
+        });
+
+        // Run beforeResponse hooks
+        for (const hook of this.beforeResponseHooks) {
+            try {
+                const result = await hook(merged, ctx);
+                if (result instanceof Response) {
+                    merged = result;
+                }
+            } catch (error) {
+                // Run error hooks
+                for (const errorHook of this.onErrorHooks) {
+                    try {
+                        const errorResponse = await errorHook(error as Error, req, ctx);
+                        if (errorResponse instanceof Response) {
+                            return errorResponse;
+                        }
+                    } catch {
+                        // Ignore errors in error hooks
+                    }
+                }
+                return new Response("Internal Server Error", { status: 500 });
+            }
+        }
+
+        // Run afterRequest hooks
+        for (const hook of this.afterRequestHooks) {
+            try {
+                const result = await hook(req, merged, ctx);
+                if (result instanceof Response) {
+                    merged = result;
+                }
+            } catch (error) {
+                // Run error hooks
+                for (const errorHook of this.onErrorHooks) {
+                    try {
+                        const errorResponse = await errorHook(error as Error, req, ctx);
+                        if (errorResponse instanceof Response) {
+                            return errorResponse;
+                        }
+                    } catch {
+                        // Ignore errors in error hooks
+                    }
+                }
+                return new Response("Internal Server Error", { status: 500 });
+            }
+        }
+
+        return merged;
+    }
+
+    private async dispatchAny(req: Request, nativeRoutes: Record<string, Record<string, (req: Request) => Promise<Response> | Response>>): Promise<Response> {
+        // Run beforeRequest hooks for unmatched routes
+        for (const hook of this.beforeRequestHooks) {
+            try {
+                const result = await hook(req);
+                if (result instanceof Response) {
+                    return result;
+                }
+                if (result instanceof Request) {
+                    req = result;
+                }
+            } catch (error) {
+                // Run error hooks
+                for (const errorHook of this.onErrorHooks) {
+                    try {
+                        const errorResponse = await errorHook(error as Error, req);
+                        if (errorResponse instanceof Response) {
+                            return errorResponse;
+                        }
+                    } catch {
+                        // Ignore errors in error hooks
+                    }
+                }
+                return new Response("Internal Server Error", { status: 500 });
+            }
+        }
+
+        const url = new URL(req.url);
+        const method = req.method.toUpperCase() as Method;
+
+        // 1) If native routes contain exact match, prefer that
+        const exact = nativeRoutes[url.pathname];
+        if (exact) {
+            const h = exact[method] || exact["DEFAULT"];
+            if (h) return await h(req);
+        }
+
+        // 2) Fallback to our matcher list
+        for (const r of this.routes) {
+            if (r.matcher === null) continue; // exact paths handled above
+            if (r.method !== method && r.method !== "DEFAULT") continue;
+            const m = url.pathname.match(r.matcher);
+            if (m) return this.dispatch(r, req);
+        }
+
+        // Create 404 response
+        let notFoundResponse = new Response("Not Found", { status: 404 });
+
+        // Run beforeResponse hooks for 404
+        for (const hook of this.beforeResponseHooks) {
+            try {
+                const result = await hook(notFoundResponse);
+                if (result instanceof Response) {
+                    notFoundResponse = result;
+                }
+            } catch (error) {
+                // Run error hooks
+                for (const errorHook of this.onErrorHooks) {
+                    try {
+                        const errorResponse = await errorHook(error as Error, req);
+                        if (errorResponse instanceof Response) {
+                            return errorResponse;
+                        }
+                    } catch {
+                        // Ignore errors in error hooks
+                    }
+                }
+                return new Response("Internal Server Error", { status: 500 });
+            }
+        }
+
+        // Run afterRequest hooks for 404
+        for (const hook of this.afterRequestHooks) {
+            try {
+                const result = await hook(req, notFoundResponse);
+                if (result instanceof Response) {
+                    notFoundResponse = result;
+                }
+            } catch (error) {
+                // Run error hooks
+                for (const errorHook of this.onErrorHooks) {
+                    try {
+                        const errorResponse = await errorHook(error as Error, req);
+                        if (errorResponse instanceof Response) {
+                            return errorResponse;
+                        }
+                    } catch {
+                        // Ignore errors in error hooks
+                    }
+                }
+                return new Response("Internal Server Error", { status: 500 });
+            }
+        }
+
+        return notFoundResponse;
+    }
+
+    private extractParams(route: InternalRoute, pathname: string): Record<string, string> {
+        if (!route.matcher) return {};
+        const match = pathname.match(route.matcher);
+        if (!match) return {};
+        const params: Record<string, string> = {};
+        for (let i = 0; i < route.paramNames.length; i++) {
+            const name = route.paramNames[i];
+            const value = match[i + 1] ?? "";
+            params[name] = decodeURIComponent(value);
+        }
+        return params;
+    }
+}
+
+export { z }
+
+export function createRoute<P extends string, S extends RouteSchema | undefined>(
+    handler: Handler<P, S>,
+    schema?: S
+): {
+    handler: Handler<P, S>;
+    schema: S | undefined;
+} {
+    return {
+        handler,
+        schema
+    };
+}

package/tsconfig.json

@@ -1,9 +1,9 @@
 {
   "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
     "target": "ESNext",
-    "module": "Preserve",
+    "module": "ESNext",
     "moduleDetection": "force",
     "jsx": "react-jsx",
     "allowJs": true,
@@ -18,8 +18,6 @@
     "strict": true,
     "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
 
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,