@coherent.js/api 1.0.0-beta.3 → 1.0.0-beta.6

package/dist/index.cjs

@@ -56,6 +56,7 @@ module.exports = __toCommonJS(index_exports);
 var import_node_crypto = require("node:crypto");
 
 // src/errors.js
+var import_node_process = require("node:process");
 var ApiError = class _ApiError extends Error {
   /**
    * Create an API _error
@@ -162,7 +163,7 @@ function createErrorHandler() {
     if (_error.details) {
       response.details = _error.details;
     }
-    if (true) {
+    if (import_node_process.env.NODE_ENV === "development") {
       response.stack = _error.stack;
     }
     res.status(response.statusCode).json(response);
@@ -194,8 +195,10 @@ function validateAgainstSchema(schema, data) {
       for (const [field, fieldSchema] of Object.entries(schema.properties)) {
         if (field in data) {
           const fieldValue = data[field];
-          const fieldErrors = validateField(fieldSchema, fieldValue, field);
-          errors.push(...fieldErrors);
+          const fieldResult = validateField(fieldSchema, fieldValue, field);
+          if (!fieldResult.valid) {
+            errors.push(...fieldResult.errors);
+          }
         }
       }
     }
@@ -207,6 +210,15 @@ function validateAgainstSchema(schema, data) {
 }
 function validateField(schema, value, fieldName) {
   const errors = [];
+  if (value === null || value === void 0) {
+    if (schema.type && schema.type !== "null") {
+      errors.push({
+        field: fieldName,
+        message: `Expected ${schema.type}, got ${value === null ? "null" : "undefined"}`
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
   if (schema.type) {
     if (schema.type === "string" && typeof value !== "string") {
       errors.push({
@@ -230,7 +242,7 @@ function validateField(schema, value, fieldName) {
       });
     }
   }
-  if (schema.type === "string") {
+  if (schema.type === "string" && typeof value === "string") {
     if (schema.minLength && value.length < schema.minLength) {
       errors.push({
         field: fieldName,
@@ -250,7 +262,7 @@ function validateField(schema, value, fieldName) {
       });
     }
   }
-  if (schema.type === "number") {
+  if (schema.type === "number" && typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       errors.push({
         field: fieldName,
@@ -264,7 +276,7 @@ function validateField(schema, value, fieldName) {
       });
     }
   }
-  return errors;
+  return { valid: errors.length === 0, errors };
 }
 function withValidation(schema) {
   return (req, res, next) => {
@@ -494,6 +506,9 @@ function registerRoute(method, config, router, path) {
     }
   }, { name });
 }
+function isStaticRoute(pattern) {
+  return !pattern.includes(":") && !pattern.includes("*") && !pattern.includes("(") && !pattern.includes("?");
+}
 var SimpleRouter = class {
   constructor(options = {}) {
     this.routes = [];
@@ -505,6 +520,7 @@ var SimpleRouter = class {
     this.enableCompilation = options.enableCompilation !== false;
     this.compiledRoutes = /* @__PURE__ */ new Map();
     this.routeCompilationCache = /* @__PURE__ */ new Map();
+    this.maxCompilationCacheSize = options.maxCompilationCacheSize || 1e3;
     this.enableVersioning = options.enableVersioning || false;
     this.defaultVersion = options.defaultVersion || "v1";
     this.versionHeader = options.versionHeader || "api-version";
@@ -533,10 +549,15 @@ var SimpleRouter = class {
         // Track WebSocket messages
       };
     }
+    this.enableSecurityHeaders = options.enableSecurityHeaders !== false;
+    this.enableCORS = options.enableCORS !== false;
+    this.enableSmartRouting = options.enableSmartRouting !== false;
+    this.staticRoutes = /* @__PURE__ */ new Map();
+    this.enableRouteMetrics = options.enableRouteMetrics || false;
   }
   /**
    * Add an HTTP route to the router
-   * 
+   *
    * @param {string} method - HTTP method (GET, POST, PUT, DELETE, PATCH)
    * @param {string} path - Route path pattern (supports :param and wildcards)
    * @param {Function} handler - Route handler function
@@ -544,7 +565,7 @@ var SimpleRouter = class {
    * @param {Array} [options.middleware] - Route-specific middleware
    * @param {string} [options.name] - Named route for URL generation
    * @param {string} [options.version] - API version for this route
-   * 
+   *
    * @example
    * router.addRoute('GET', '/users/:id', (req, res) => {
    *   return { user: { id: req.params.id } };
@@ -567,6 +588,11 @@ var SimpleRouter = class {
     if (this.enableCompilation) {
       route.compiled = this.compileRoute(fullPath);
     }
+    if (this.enableSmartRouting && isStaticRoute(fullPath)) {
+      const staticKey = `${route.method}:${fullPath}`;
+      this.staticRoutes.set(staticKey, route);
+      route.isStatic = true;
+    }
     this.routes.push(route);
     if (this.enableVersioning) {
       if (!this.versionedRoutes.has(route.version)) {
@@ -880,7 +906,7 @@ var SimpleRouter = class {
       }
     });
     socket.on("_error", (err) => {
-      console.log("WebSocket socket _error (connection likely closed):", err.code);
+      console.error("WebSocket socket _error (connection likely closed):", err.code);
     });
     return ws;
   }
@@ -939,7 +965,7 @@ var SimpleRouter = class {
         try {
           ws.send(message);
         } catch {
-          console.log("Failed to send message to connection:", id);
+          console.error("Failed to send message to connection:", id);
         }
       }
     }
@@ -977,16 +1003,16 @@ var SimpleRouter = class {
   }
   /**
    * Generate URL for named route with parameter substitution
-   * 
+   *
    * @param {string} name - Route name (set during route registration)
    * @param {Object} [params={}] - Parameters to substitute in the URL pattern
    * @returns {string} Generated URL with parameters substituted
    * @throws {Error} If named route is not found
-   * 
+   *
    * @example
    * // Route registered as: router.addRoute('GET', '/users/:id', handler, { name: 'getUser' })
    * const url = router.url('getUser', { id: 123 }); // '/users/123'
-   * 
+   *
    * // With constrained parameters
    * const url = router.url('getUserPosts', { userId: 123, postId: 456 }); // '/users/123/posts/456'
    */
@@ -1004,11 +1030,11 @@ var SimpleRouter = class {
   }
   /**
    * Add routes from configuration object
-   * 
+   *
    * @param {Object} routeConfig - Route configuration object with nested structure
    * @description Processes nested route objects and registers HTTP and WebSocket routes.
    * Supports declarative route definition with automatic method detection.
-   * 
+   *
    * @example
    * router.addRoutes({
    *   'api': {
@@ -1024,17 +1050,17 @@ var SimpleRouter = class {
   }
   /**
    * Add global middleware to the router
-   * 
+   *
    * @param {Function|Object} middleware - Middleware function or conditional middleware object
    * @description Adds middleware that runs before all route handlers. Supports both
    * simple functions and conditional middleware objects.
-   * 
+   *
    * @example
    * // Simple middleware
    * router.use((req, res) => {
    *   console.log(`${req.method} ${req.url}`);
    * });
-   * 
+   *
    * // Conditional middleware
    * router.use({
    *   condition: (req) => req.url.startsWith('/api'),
@@ -1164,7 +1190,10 @@ var SimpleRouter = class {
   compileRoute(pattern) {
     if (this.routeCompilationCache.has(pattern)) {
       if (this.enableMetrics) this.metrics.compilationHits++;
-      return this.routeCompilationCache.get(pattern);
+      const compiled2 = this.routeCompilationCache.get(pattern);
+      this.routeCompilationCache.delete(pattern);
+      this.routeCompilationCache.set(pattern, compiled2);
+      return compiled2;
     }
     const paramNames = [];
     let regexPattern = pattern;
@@ -1175,25 +1204,38 @@ var SimpleRouter = class {
       regexPattern = regexPattern.replace(/\/\*/g, "/([^/]+)");
       paramNames.push("splat");
     }
-    regexPattern = regexPattern.replace(/:([^(/]+)(\([^)]+\))?(\?)?/g, (match, paramName, constraint, optional) => {
+    regexPattern = regexPattern.replace(/:([^(/]+)(\([^)]+\))?(\?)?/g, (match, paramName, constraint, optional, offset, fullString) => {
       paramNames.push(paramName);
-      if (constraint) {
-        const constraintPattern = constraint.slice(1, -1);
-        return optional ? `(?:/(?:${constraintPattern}))?` : `/(${constraintPattern})`;
+      const hasPrecedingSlash = offset > 0 && fullString[offset - 1] === "/";
+      if (hasPrecedingSlash) {
+        if (constraint) {
+          const constraintPattern = constraint.slice(1, -1);
+          return optional ? `(?:/(?:${constraintPattern}))?` : `(${constraintPattern})`;
+        } else {
+          return optional ? `(?:([^/]+))?` : `([^/]+)`;
+        }
       } else {
-        return optional ? "(?:/([^/]+))?" : "/([^/]+)";
+        if (constraint) {
+          const constraintPattern = constraint.slice(1, -1);
+          return optional ? `(?:/(?:${constraintPattern}))?` : `/${constraintPattern}`;
+        } else {
+          return optional ? `(?:/([^/]+))?` : `/([^/]+)`;
+        }
       }
     });
-    regexPattern = regexPattern.replace(/[.+?^${}|[\]\\]/g, "\\$&").replace(/\\\(/g, "(").replace(/\\\)/g, ")").replace(/\\\?/g, "?");
+    regexPattern = regexPattern.replace(/([.+?^${}|\\[\]()]])/g, "\\$1");
+    regexPattern = regexPattern.replace(/\\\[/g, "[").replace(/\\\]/g, "]").replace(/\\\^/g, "^");
     regexPattern = `^${regexPattern}$`;
     const compiled = {
       regex: new RegExp(regexPattern),
       paramNames,
       pattern
     };
-    if (this.routeCompilationCache.size < 1e3) {
-      this.routeCompilationCache.set(pattern, compiled);
+    if (this.routeCompilationCache.size >= this.maxCompilationCacheSize) {
+      const firstKey = this.routeCompilationCache.keys().next().value;
+      this.routeCompilationCache.delete(firstKey);
     }
+    this.routeCompilationCache.set(pattern, compiled);
     return compiled;
   }
   /**
@@ -1369,7 +1411,15 @@ var SimpleRouter = class {
       this.metrics.requests++;
     }
     const { corsOrigin, rateLimit = { windowMs: 6e4, maxRequests: 100 } } = options;
-    addSecurityHeaders(res, corsOrigin);
+    if (this.enableSecurityHeaders) {
+      addSecurityHeaders(res, corsOrigin);
+    } else if (this.enableCORS) {
+      const origin = corsOrigin || "http://localhost:3000";
+      res.setHeader("Access-Control-Allow-Origin", origin);
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+    }
     if (req.method === "OPTIONS") {
       res.writeHead(204);
       res.end();
@@ -1383,7 +1433,9 @@ var SimpleRouter = class {
     }
     const parsedUrl = (0, import_node_url.parse)(req.url, true);
     const pathname = parsedUrl.pathname;
-    req.query = parsedUrl.query || {};
+    if (!req.query) {
+      req.query = parsedUrl.query || {};
+    }
     try {
       req.body = await parseBody(req, options.maxBodySize);
     } catch (_error) {
@@ -1403,24 +1455,48 @@ var SimpleRouter = class {
       if (this.enableMetrics && requestVersion) {
         this.metrics.versionRequests.set(requestVersion, (this.metrics.versionRequests.get(requestVersion) || 0) + 1);
       }
-      const routesToSearch = this.enableVersioning && this.versionedRoutes.has(requestVersion) ? this.versionedRoutes.get(requestVersion) : this.routes;
-      for (const route of routesToSearch) {
-        if (route.method === req.method) {
-          if (this.enableVersioning && route.version !== requestVersion) {
-            continue;
-          }
-          let params = null;
-          if (this.enableCompilation && route.compiled) {
-            params = this.matchCompiledRoute(route.compiled, pathname);
-          } else {
-            params = extractParams(route.path, pathname);
+      matchedRoute = null;
+      if (this.enableSmartRouting) {
+        const staticKey = `${req.method}:${pathname}`;
+        const staticRoute = this.staticRoutes.get(staticKey);
+        if (staticRoute) {
+          if (!this.enableVersioning || staticRoute.version === requestVersion) {
+            matchedRoute = { route: staticRoute, params: {} };
+            if (this.enableRouteMetrics && this.enableMetrics) {
+              if (!this.metrics.staticRouteMatches) {
+                this.metrics.staticRouteMatches = 0;
+              }
+              this.metrics.staticRouteMatches++;
+            }
           }
-          if (params !== null) {
-            matchedRoute = { route, params };
-            if (this.routeCache.size < this.maxCacheSize) {
-              this.routeCache.set(cacheKey, matchedRoute);
+        }
+      }
+      if (!matchedRoute) {
+        const routesToSearch = this.enableVersioning && this.versionedRoutes.has(requestVersion) ? this.versionedRoutes.get(requestVersion) : this.routes;
+        for (const route of routesToSearch) {
+          if (route.method === req.method) {
+            if (this.enableVersioning && route.version !== requestVersion) {
+              continue;
+            }
+            let params = null;
+            if (this.enableCompilation && route.compiled) {
+              params = this.matchCompiledRoute(route.compiled, pathname);
+            } else {
+              params = extractParams(route.path, pathname);
+            }
+            if (params !== null) {
+              matchedRoute = { route, params };
+              if (this.enableRouteMetrics && this.enableMetrics) {
+                if (!this.metrics.dynamicRouteMatches) {
+                  this.metrics.dynamicRouteMatches = 0;
+                }
+                this.metrics.dynamicRouteMatches++;
+              }
+              if (this.routeCache.size < this.maxCacheSize) {
+                this.routeCache.set(cacheKey, matchedRoute);
+              }
+              break;
             }
-            break;
           }
         }
       }
@@ -1431,7 +1507,6 @@ var SimpleRouter = class {
         const routeKey = `${req.method}:${matchedRoute.route.path}`;
         this.metrics.routeMatches.set(routeKey, (this.metrics.routeMatches.get(routeKey) || 0) + 1);
       }
-      console.log(`${(/* @__PURE__ */ new Date()).toISOString()} ${req.method} ${pathname}`);
       try {
         if (matchedRoute.route.middleware && matchedRoute.route.middleware.length > 0) {
           for (const middleware of matchedRoute.route.middleware) {
@@ -1441,16 +1516,26 @@ var SimpleRouter = class {
         }
         const { route } = matchedRoute;
         const result = await route.handler(req, res);
-        if (result && typeof result === "object" && !res.headersSent) {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(result));
+        if (result && !res.headersSent) {
+          if (typeof result === "object") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+          } else if (typeof result === "string") {
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(result);
+          }
         }
         if (this.enableMetrics) {
           const responseTime = Date.now() - startTime;
-          this.metrics.responseTime.push(responseTime);
-          if (this.metrics.responseTime.length > 1e3) {
-            this.metrics.responseTime = this.metrics.responseTime.slice(-1e3);
+          if (!this._metricsLock) {
+            this._metricsLock = Promise.resolve();
           }
+          this._metricsLock = this._metricsLock.then(() => {
+            this.metrics.responseTime.push(responseTime);
+            if (this.metrics.responseTime.length > 1e3) {
+              this.metrics.responseTime = this.metrics.responseTime.slice(-1e3);
+            }
+          });
         }
         return;
       } catch (_error) {
@@ -1494,6 +1579,49 @@ var SimpleRouter = class {
   head(path, handler, options = {}) {
     return this.addRoute("HEAD", path, handler, options);
   }
+  /**
+   * Convert to Express Router middleware
+   *
+   * @param {Object} express - Express module (required)
+   * @returns {Function} Express-compatible router middleware
+   *
+   * @example
+   * import express from 'express';
+   * const router = createRouter();
+   * router.get('/users', handler);
+   * app.use('/api', router.toExpressRouter(express));
+   */
+  toExpressRouter(express) {
+    if (!express || typeof express.Router !== "function") {
+      throw new Error("Express is required for toExpressRouter(). Pass the express module as argument: router.toExpressRouter(express)");
+    }
+    const expressRouter = express.Router();
+    for (const route of this.routes) {
+      const method = route.method.toLowerCase();
+      const path = route.path;
+      const handler = route.handler;
+      const middleware = route.middleware || [];
+      const expressHandler = async (req, res, next) => {
+        try {
+          for (const mw of middleware) {
+            await new Promise((resolve, reject) => {
+              mw(req, res, (err) => err ? reject(err) : resolve());
+            });
+          }
+          const result = await handler(req, res);
+          if (result !== void 0 && !res.headersSent) {
+            res.json(result);
+          }
+        } catch (error) {
+          next(error);
+        }
+      };
+      if (typeof expressRouter[method] === "function") {
+        expressRouter[method](path, expressHandler);
+      }
+    }
+    return expressRouter;
+  }
 };
 function createRouter(routeConfig, options = {}) {
   const router = new SimpleRouter(options);