@getvision/server 0.2.0-b49d8db-develop → 0.2.1-648a711-develop

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @getvision/server
 
+## 0.2.0
+
+### Minor Changes
+
+- b49d8db: Added per-endpoint rate limiting with hono-rate-limiter: configure ratelimit in EndpointConfig with requests, window, and optional store for distributed caching. Includes docs and example.
+
 ## 0.1.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getvision/server",
-  "version": "0.2.0-b49d8db-develop",
+  "version": "0.2.1-648a711-develop",
   "type": "module",
   "description": "Vision Server - Meta-framework with built-in observability, pub/sub, and type-safe APIs",
   "exports": {

package/src/event-bus.ts

@@ -26,12 +26,52 @@ export class EventBus {
   private devModeHandlers = new Map<string, Array<(data: any) => Promise<void>>>()
 
   constructor(config: EventBusConfig = {}) {
-    this.config = {
-      devMode: config.devMode ?? process.env.NODE_ENV === 'development',
-      redis: config.redis ?? {
+    // Build Redis config from environment variables
+    const envUrl = process.env.REDIS_URL
+    let envRedis: { host?: string; port?: number; password?: string } | undefined
+    if (envUrl) {
+      try {
+        const u = new URL(envUrl)
+        envRedis = {
+          host: u.hostname || undefined,
+          port: u.port ? parseInt(u.port) : 6379,
+          // URL password takes precedence over REDIS_PASSWORD
+          password: u.password || process.env.REDIS_PASSWORD || undefined,
+        }
+      } catch {
+        // Fallback to individual env vars if URL is invalid
+        envRedis = undefined
+      }
+    }
+
+    if (!envRedis) {
+      envRedis = {
         host: process.env.REDIS_HOST || 'localhost',
         port: parseInt(process.env.REDIS_PORT || '6379'),
-      },
+        password: process.env.REDIS_PASSWORD || undefined,
+      }
+    }
+
+    // Merge: explicit config.redis overrides env-derived values
+    const mergedRedis = { ...(envRedis || {}), ...(config.redis || {}) }
+
+    // Determine if Redis is configured by env or explicit config
+    const hasRedisFromEnv = Boolean(envUrl)
+    const hasRedisFromConfig = Boolean(
+      config.redis && (config.redis.host || config.redis.port || config.redis.password)
+    )
+    const hasRedis = hasRedisFromEnv || hasRedisFromConfig
+
+    // devMode precedence:
+    // 1) Respect explicit config.devMode when provided (true/false)
+    // 2) Otherwise, if Redis is configured (env or config), use production mode (devMode=false)
+    // 3) Otherwise, default to devMode=true (in-memory)
+    const resolvedDevMode =
+      typeof config.devMode === 'boolean' ? config.devMode : !hasRedis
+
+    this.config = {
+      devMode: resolvedDevMode,
+      redis: mergedRedis,
     }
   }
 

package/src/service.ts

@@ -32,6 +32,44 @@ function getClientKey(c: Context, method: string, path: string): string {
   return `${ip || ua}:${method}:${path}`
 }
 
+/**
+ * Create a minimal Hono-like Context for event handlers
+ * so service-level middleware can populate c.set(...)
+ */
+function createEventContext<E extends Env = any, I extends Input = {}>(): Context<E, any, I> {
+  const store: Record<string, any> = {}
+  const fake: Partial<Context<E, any, I>> = {
+    get: (key: string) => store[key],
+    set: (key: string, value: any) => { store[key] = value },
+    req: {
+      header: () => undefined,
+      param: () => ({}),
+      query: () => ({}),
+      json: async () => ({}),
+      raw: {} as any,
+    } as any,
+  }
+  return fake as Context<E, any, I>
+}
+
+/**
+ * Run Hono middleware chain on a context
+ */
+async function runMiddlewareChain<E extends Env, I extends Input>(
+  middlewares: MiddlewareHandler<E, string, any, any>[],
+  c: Context<E, any, I>
+): Promise<void> {
+  let index = -1
+  const dispatch = async (i: number): Promise<void> => {
+    if (i <= index) throw new Error('next() called multiple times')
+    index = i
+    const mw = middlewares[i]
+    if (!mw) return
+    await mw(c, () => dispatch(i + 1))
+  }
+  await dispatch(0)
+}
+
 /**
  * Event schema map - accumulates event types as they're registered
  */
@@ -202,7 +240,7 @@ export class ServiceBuilder<
       description?: string
       icon?: string
       tags?: string[]
-      handler: (event: T) => Promise<void>
+      handler: (event: T, c: Context<E, any, I>) => Promise<void>
     }
   ): ServiceBuilder<TEvents & { [key in K]: T }, E, I> {
     const { schema, handler, description, icon, tags } = config
@@ -210,16 +248,27 @@ export class ServiceBuilder<
     // Store schema for type inference
     this.eventSchemas[eventName] = schema
     
-    // Register in event registry
+    // Wrap handler to provide Hono-like context with middleware support
+    const wrappedHandler = async (data: T) => {
+      const ctx = createEventContext<E, I>()
+      // Run service-level middleware to populate ctx (e.g., c.set('db', db))
+      if (this.globalMiddleware.length > 0) {
+        await runMiddlewareChain(this.globalMiddleware, ctx)
+      }
+      // Call original handler with event data and context
+      await handler(data, ctx)
+    }
+    
+    // Register wrapped handler in event registry (for metadata/stats)
     eventRegistry.registerEvent(
       eventName,
       schema,
-      handler,
+      wrappedHandler,
       { description, icon, tags }
     )
     
-    // Register handler in event bus
-    this.eventBus.registerHandler(eventName, handler)
+    // Register wrapped handler in event bus
+    this.eventBus.registerHandler(eventName, wrappedHandler)
     
     // Store for later reference
     this.eventHandlers.set(eventName, config)

package/src/vision-app.ts

@@ -17,6 +17,30 @@ export interface VisionALSContext {
 
 const visionContext = new AsyncLocalStorage<VisionALSContext>()
 
+// Simple deep merge utility (objects only, arrays are overwritten by source)
+function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
+  const output: any = { ...target }
+  if (source && typeof source === 'object') {
+    for (const key of Object.keys(source)) {
+      const srcVal = source[key]
+      const tgtVal = output[key]
+      if (
+        srcVal &&
+        typeof srcVal === 'object' &&
+        !Array.isArray(srcVal) &&
+        tgtVal &&
+        typeof tgtVal === 'object' &&
+        !Array.isArray(tgtVal)
+      ) {
+        output[key] = deepMerge(tgtVal, srcVal)
+      } else {
+        output[key] = srcVal
+      }
+    }
+  }
+  return output as T
+}
+
 /**
  * Vision Server configuration
  */
@@ -61,20 +85,13 @@ export interface VisionConfig {
  *   service: {
  *     name: 'My API',
  *     version: '1.0.0'
- *   },
- *   pubsub: {
- *     schemas: {
- *       'user/created': {
- *         data: z.object({ userId: z.string() })
- *       }
- *     }
  *   }
  * })
  * 
  * const userService = app.service('users')
- *   .endpoint('GET', '/users/:id', schema, handler)
  *   .on('user/created', handler)
- * 
+ *   .endpoint('GET', '/users/:id', schema, handler)
+ *
  * app.start(3000)
  * ```
  */
@@ -100,24 +117,16 @@ export class Vision<
         enabled: false,
         port: 9500,
       },
-      pubsub: {
-        devMode: true,
-      },
+      // Do not set a default devMode here; let EventBus derive from Redis presence
+      pubsub: {},
       routes: {
         autodiscover: true,
         dirs: ['app/routes'],
       },
     }
 
-    // Merge shallowly (good enough for our config structure)
-    this.config = {
-      ...defaultConfig,
-      ...(config || {}),
-      service: { ...defaultConfig.service, ...(config?.service || {}) },
-      vision: { ...defaultConfig.vision, ...(config?.vision || {}) },
-      pubsub: { ...defaultConfig.pubsub, ...(config?.pubsub || {}) },
-      routes: { ...defaultConfig.routes, ...(config?.routes || {}) },
-    }
+    // Deep merge to respect nested overrides
+    this.config = deepMerge(defaultConfig, config || {})
     
     // Initialize Vision Core
     const visionEnabled = this.config.vision?.enabled !== false