npm - bxo - Versions diffs - 0.0.5-dev.65 → 0.0.5-dev.66 - Mend

bxo 0.0.5-dev.65 → 0.0.5-dev.66

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

package/README.md +83 -675
package/example/cors-example.ts +49 -0
package/example/index.html +5 -0
package/example/index.ts +57 -0
package/package.json +9 -15
package/plugins/cors.ts +124 -98
package/plugins/index.ts +2 -9
package/plugins/openapi.ts +130 -0
package/src/index.ts +646 -59
package/tsconfig.json +3 -5
package/.cursor/rules/use-bun-instead-of-node-vite-npm-pnpm.mdc +0 -111
package/examples/serve-react/README.md +0 -15
package/examples/serve-react/app.tsx +0 -8
package/examples/serve-react/bun.lock +0 -42
package/examples/serve-react/index.html +0 -9
package/examples/serve-react/index.ts +0 -27
package/examples/serve-react/package.json +0 -17
package/examples/serve-react/tsconfig.json +0 -29
package/index.ts +0 -5
package/plugins/README.md +0 -160
package/plugins/ratelimit.ts +0 -136
package/src/core/bxo.ts +0 -458
package/src/handlers/request-handler.ts +0 -230
package/src/types/index.ts +0 -167
package/src/utils/context-factory.ts +0 -158
package/src/utils/helpers.ts +0 -40
package/src/utils/index.ts +0 -448
package/src/utils/response-handler.ts +0 -293
package/src/utils/route-matcher.ts +0 -191
package/tests/README.md +0 -359
package/tests/integration/bxo.test.ts +0 -616
package/tests/run-tests.ts +0 -44
package/tests/unit/context-factory.test.ts +0 -386
package/tests/unit/helpers.test.ts +0 -253
package/tests/unit/response-handler.test.ts +0 -327
package/tests/unit/route-matcher.test.ts +0 -181
package/tests/unit/utils.test.ts +0 -475

package/example/cors-example.ts ADDED Viewed

@@ -0,0 +1,49 @@
+import BXO from "../src/index";
+import { cors } from "../plugins";
+const app = new BXO();
+// Use the CORS plugin
+app.use(cors({
+  origin: ["http://localhost:3000", "http://localhost:3001"],
+  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  allowedHeaders: ["Content-Type", "Authorization"],
+  credentials: true
+}));
+// Add some routes
+app.get("/api/users", async (ctx) => {
+  return ctx.json([
+    { id: 1, name: "John Doe" },
+    { id: 2, name: "Jane Smith" }
+  ]);
+});
+app.post("/api/users", async (ctx) => {
+  const user = ctx.body as { name: string };
+  return ctx.json({ id: 3, name: user.name }, 201);
+});
+// Custom beforeRequest hook example
+app.beforeRequest(async (req) => {
+  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
+  return req; // Continue with the request
+});
+// Custom afterRequest hook example
+app.afterRequest(async (req, res) => {
+  console.log(`[${new Date().toISOString()}] Response: ${res.status}`);
+  return res; // Return the modified response
+});
+// Custom error handler
+app.onError(async (error, req) => {
+  console.error(`Error handling ${req.method} ${req.url}:`, error);
+  return new Response("Something went wrong", { status: 500 });
+});
+// Start the server
+app.start();
+console.log("Server running on http://localhost:3000");
+console.log("Try making a CORS request from another origin!");

package/example/index.html ADDED Viewed

@@ -0,0 +1,5 @@
+<html>
+    <body>
+        <h1>Hello, world!</h1>
+    </body>
+</html>

package/example/index.ts ADDED Viewed

@@ -0,0 +1,57 @@
+import BXO, { z } from "../src";
+import index from "./index.html";
+import openapi from "../plugins/openapi";
+async function main() {
+    const bxo = new BXO();
+    bxo.default("/", index);
+    bxo.get("/:id", (ctx) => {
+        return new Response(ctx.params.id + ctx.query.name, {
+            headers: {
+                "Content-Type": "text/html"
+            }
+        });
+    }, {
+        query: z.object({
+            name: z.number()
+        }),
+        response: {
+            200: z.object({
+                name: z.string()
+            })
+        },
+    });
+    bxo.post("/", (ctx) => {
+        console.log(ctx.body)
+        return new Response("Hello" + ctx.body.name, {
+            headers: {
+                "Content-Type": "text/html"
+            }
+        });
+    }, {
+        detail: {
+            defaultContentType: "multipart/form-data"
+        },
+        body: z.object({
+            name: z.string(),
+            avatar: z.file()
+        }),
+        response: {
+            200: z.object({
+                name: z.string()
+            }),
+            400: z.object({
+                error: z.string()
+            })
+        }
+    });
+    bxo.use(openapi())
+    bxo.start();
+    console.log(`Server is running on http://localhost:${bxo.server?.port}`);
+}
+main();

package/package.json CHANGED Viewed

@@ -1,26 +1,20 @@
 {
   "name": "bxo",
-  "module": "index.ts",
-  "version": "0.0.5-dev.65",
-  "description": "A simple and lightweight web framework for Bun",
-  "type": "module",
+  "module": "./src/index.ts",
   "exports": {
-    ".": "./index.ts",
+    ".": "./src/index.ts",
     "./plugins": "./plugins/index.ts"
   },
+  "version": "0.0.5-dev.66",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
   "peerDependencies": {
     "typescript": "^5"
   },
   "dependencies": {
-    "zod": "^3.25.76",
-    "@types/bun": "latest"
-  },
-  "scripts": {
-    "test": "bun test",
-    "test:unit": "bun test tests/unit/",
-    "test:integration": "bun test tests/integration/",
-    "test:all": "bun run tests/run-tests.ts",
-    "test:watch": "bun test --watch",
-    "test:coverage": "bun test --coverage"
+    "zod": "^4.1.5",
+    "zod-openapi": "^5.4.0"
   }
 }

package/plugins/cors.ts CHANGED Viewed

@@ -1,107 +1,133 @@
-import type { Plugin } from '../index';
-interface CORSOptions {
-  origin?: string | string[] | boolean;
-  methods?: string[];
-  allowedHeaders?: string[];
-  credentials?: boolean;
-  maxAge?: number;
+import BXO from "../src/index";
+export interface CorsOptions {
+    origin?: string | string[] | boolean | ((origin: string) => boolean);
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
 }
-// Helper function to extract origin from request headers
-function getRequestOrigin(request: Request): string | null {
-  // Try Origin header first (standard for CORS)
-  const origin = request.headers.get('origin');
-  if (origin) {
-    return origin;
-  }
-  // Fallback to Referer header
-  const referer = request.headers.get('referer');
-  if (referer) {
-    try {
-      const url = new URL(referer);
-      return `${url.protocol}//${url.host}`;
-    } catch (e) {
-      // Invalid referer URL, ignore it
-      return null;
-    }
-  }
+export function cors(options: CorsOptions = {}): BXO {
+    const {
+        origin = "*",
+        methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"],
+        allowedHeaders = ["Content-Type", "Authorization"],
+        exposedHeaders = [],
+        credentials = false,
+        maxAge = 86400,
+        preflightContinue = false
+    } = options;
-  return null;
-}
+    const plugin = new BXO();
-// Helper function to validate origin against allowed origins
-function validateOrigin(requestOrigin: string | null, allowedOrigins: string | string[] | boolean): string | null {
-  if (!requestOrigin) {
-    return null;
-  }
-  if (typeof allowedOrigins === 'boolean') {
-    return allowedOrigins ? requestOrigin : null;
-  } else if (typeof allowedOrigins === 'string') {
-    return allowedOrigins === '*' || allowedOrigins === requestOrigin ? requestOrigin : null;
-  } else if (Array.isArray(allowedOrigins)) {
-    return allowedOrigins.includes(requestOrigin) ? requestOrigin : null;
-  }
-  return null;
-}
+    // Handle CORS preflight requests
+    plugin.beforeRequest(async (req) => {
+        const requestOrigin = req.headers.get("origin");
+        const requestMethod = req.method;
-export function cors(options: CORSOptions = {}): Plugin {
-  const {
-    origin = '*',
-    methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
-    allowedHeaders = ['Content-Type', 'Authorization'],
-    credentials = false,
-    maxAge = 86400
-  } = options;
-  return {
-    name: 'cors',
-    onRequest: async (ctx) => {
-      // Handle preflight OPTIONS requests
-      if (ctx.request.method === 'OPTIONS') {
-        const requestOrigin = getRequestOrigin(ctx.request);
-        const allowedOrigin = validateOrigin(requestOrigin, origin);
-        // Set CORS headers for preflight
-        ctx.set.headers = {
-          ...ctx.set.headers,
-          'Access-Control-Allow-Origin': allowedOrigin || '*',
-          'Access-Control-Allow-Methods': methods.join(', '),
-          'Access-Control-Allow-Headers': allowedHeaders.join(', '),
-          'Access-Control-Max-Age': maxAge.toString()
-        };
-        if (credentials) {
-          ctx.set.headers['Access-Control-Allow-Credentials'] = 'true';
+        // Handle preflight OPTIONS request
+        if (requestMethod === "OPTIONS") {
+            const response = new Response(null, { status: 204 });
+            // Set CORS headers
+            setCorsHeaders(response, {
+                origin,
+                methods,
+                allowedHeaders,
+                exposedHeaders,
+                credentials,
+                maxAge,
+                requestOrigin
+            });
+            if (!preflightContinue) {
+                return response;
+            }
         }
-        // Return a proper Response for OPTIONS requests
-        return new Response(null, {
-          status: 204,
-          headers: ctx.set.headers
+        // Continue with normal request processing
+        return req;
+    });
+    // Add CORS headers to all responses
+    plugin.afterRequest(async (req, res) => {
+        const requestOrigin = req.headers.get("origin");
+        // Set CORS headers on the response
+        setCorsHeaders(res, {
+            origin,
+            methods,
+            allowedHeaders,
+            exposedHeaders,
+            credentials,
+            maxAge,
+            requestOrigin
         });
-      }
-    },
-    onResponse: async (ctx) => {
-      // Handle CORS headers for actual requests
-      const requestOrigin = getRequestOrigin(ctx.request);
-      const allowedOrigin = validateOrigin(requestOrigin, origin);
-      // Set CORS headers for all responses
-      ctx.set.headers = {
-        ...ctx.set.headers,
-        'Access-Control-Allow-Origin': allowedOrigin || '*',
-        'Access-Control-Allow-Methods': methods.join(', '),
-        'Access-Control-Allow-Headers': allowedHeaders.join(', '),
-        'Access-Control-Max-Age': maxAge.toString()
-      };
-      if (credentials) {
-        ctx.set.headers['Access-Control-Allow-Credentials'] = 'true';
-      }
+        return res;
+    });
+    return plugin;
+}
+function setCorsHeaders(
+    response: Response,
+    options: {
+        origin: string | string[] | boolean | ((origin: string) => boolean);
+        methods: string[];
+        allowedHeaders: string[];
+        exposedHeaders: string[];
+        credentials: boolean;
+        maxAge: number;
+        requestOrigin?: string | null;
+    }
+) {
+    const { origin, methods, allowedHeaders, exposedHeaders, credentials, maxAge, requestOrigin } = options;
+    // Set Access-Control-Allow-Origin
+    if (origin) {
+        if (typeof origin === "string") {
+            if (origin === "*") {
+                response.headers.set("Access-Control-Allow-Origin", "*");
+            } else {
+                response.headers.set("Access-Control-Allow-Origin", origin);
+            }
+        } else if (Array.isArray(origin)) {
+            // For array of origins, we need to check if the request origin is in the list
+            // This is handled in the beforeRequest hook where we have access to the request origin
+            if (options.requestOrigin && origin.includes(options.requestOrigin)) {
+                response.headers.set("Access-Control-Allow-Origin", options.requestOrigin);
+            }
+        } else if (origin === true) {
+            response.headers.set("Access-Control-Allow-Origin", "*");
+        }
+    }
+    // Set Access-Control-Allow-Methods
+    if (methods.length > 0) {
+        response.headers.set("Access-Control-Allow-Methods", methods.join(", "));
     }
-  };
-}
+    // Set Access-Control-Allow-Headers
+    if (allowedHeaders.length > 0) {
+        response.headers.set("Access-Control-Allow-Headers", allowedHeaders.join(", "));
+    }
+    // Set Access-Control-Expose-Headers
+    if (exposedHeaders.length > 0) {
+        response.headers.set("Access-Control-Expose-Headers", exposedHeaders.join(", "));
+    }
+    // Set Access-Control-Allow-Credentials
+    if (credentials) {
+        response.headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    // Set Access-Control-Max-Age
+    if (maxAge) {
+        response.headers.set("Access-Control-Max-Age", maxAge.toString());
+    }
+}

package/plugins/index.ts CHANGED Viewed

@@ -1,9 +1,2 @@
-// Export all plugins
-export { cors } from './cors';
-export { rateLimit } from './ratelimit';
-// Import types for plugin typing
-import type { Plugin } from '../index';
-// Plugin functions return Plugin instances
-export type PluginFactory<T = any> = (options?: T) => Plugin;
+export * from "./openapi";
+export * from "./cors";

package/plugins/openapi.ts ADDED Viewed

@@ -0,0 +1,130 @@
+import BXO, { z } from "../src";
+import { createDocument, type CreateDocumentOptions, type ZodOpenApiPathsObject } from "zod-openapi";
+class OpenApiConfig {
+}
+interface OpenApiPluginConfig {
+    path: string;
+    jsonPath: string;
+    openapiConfig: CreateDocumentOptions;
+}
+const createOpenApiPaths = (app: BXO, config?: OpenApiPluginConfig): ZodOpenApiPathsObject => {
+    const routes = app.getRoutes()
+    let paths: ZodOpenApiPathsObject = {}
+    for (const route of routes) {
+        const openapiPath = "/" + route.path.replace(/:(\w+)/g, "{$1}").replace(/\*/g, "*").replace(/\//g, "")
+        const method = route.method.toLowerCase()
+        if (method === "default") {
+            continue
+        }
+        const contentType = route.schema?.detail?.defaultContentType || "application/json"
+        if (config?.path && openapiPath === config?.path) {
+            continue
+        }
+        if (config?.jsonPath && openapiPath === config?.jsonPath) {
+            continue
+        }
+        if (route.schema?.detail?.hidden) {
+            continue
+        }
+        const response = Object.entries(route.schema?.response || {}).map(([status, schema]) => {
+            return ({
+                400: status === "400" && !route.schema?.response?.[status] ? {
+                    content: {
+                        "application/json": {
+                            schema: z.object({
+                                error: z.string(),
+                                issues: z.any().optional()
+                            })
+                        }
+                    }
+                } : undefined,
+                [status]: {
+                    content: {
+                        "application/json": {
+                            schema: schema
+                        }
+                    }
+                }
+            })
+        }).reduce((acc, curr) => ({ ...acc, ...curr }), {})
+        paths[openapiPath] = {
+            ...paths[openapiPath],
+            [method]: {
+                requestBody: {
+                    content: {
+                        [contentType]: {
+                            schema: route.schema?.body || z.object({})
+                        }
+                    }
+                },
+                responses: response || {
+                    200: {
+                        content: {
+                            "application/json": {
+                                schema: z.object({})
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return paths
+}
+export default function openapi(_config?: OpenApiPluginConfig) {
+    let config = _config
+    !config && (config = { path: "/docs", openapiConfig: new OpenApiConfig(), jsonPath: "/openapi.json" })
+    config.path = config.path || "/docs"
+    config.jsonPath = config.jsonPath || "/openapi.json"
+    config.openapiConfig = config.openapiConfig || {}
+    const bxo = new BXO()
+        .get(config.jsonPath, (ctx, app) => {
+            const paths = createDocument({
+                openapi: "3.0.0",
+                info: {
+                    title: "My API",
+                    version: "1.0.0"
+                },
+                paths: createOpenApiPaths(app, config),
+                ...config.openapiConfig
+            })
+            return new Response(JSON.stringify(paths), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            })
+        })
+        .get(config.path, (ctx, app) => {
+            ctx.set.headers["Content-Type"] = "text/html"
+            return `
+            <!doctype html>
+<html>
+<head>
+  <title>My Scalar API Reference</title>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+</head>
+<body>
+  <div id="app"></div>
+  <!-- Load Scalar -->
+  <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+  <!-- Initialize Scalar -->
+  <script>
+    Scalar.createApiReference('#app', {
+      url: '/openapi.json',
+      proxyUrl: 'https://proxy.scalar.com'
+    })
+  </script>
+</body>
+</html>`
+        })
+    return bxo
+}