@mantiq/core 0.0.1

package/src/session/handlers/MemorySessionHandler.ts

@@ -0,0 +1,35 @@
+import type { SessionHandler } from '../../contracts/Session.ts'
+
+interface SessionEntry {
+  data: string
+  lastActivity: number
+}
+
+/**
+ * In-memory session handler. Fast, but sessions are lost on restart.
+ * Good for development and testing.
+ */
+export class MemorySessionHandler implements SessionHandler {
+  private sessions = new Map<string, SessionEntry>()
+
+  async read(sessionId: string): Promise<string> {
+    return this.sessions.get(sessionId)?.data ?? ''
+  }
+
+  async write(sessionId: string, data: string): Promise<void> {
+    this.sessions.set(sessionId, { data, lastActivity: Date.now() })
+  }
+
+  async destroy(sessionId: string): Promise<void> {
+    this.sessions.delete(sessionId)
+  }
+
+  async gc(maxLifetimeSeconds: number): Promise<void> {
+    const cutoff = Date.now() - maxLifetimeSeconds * 1000
+    for (const [id, entry] of this.sessions) {
+      if (entry.lastActivity < cutoff) {
+        this.sessions.delete(id)
+      }
+    }
+  }
+}

package/src/websocket/WebSocketContext.ts

@@ -0,0 +1,20 @@
+import type { MantiqRequest } from '../contracts/Request.ts'
+
+export interface WebSocketContext {
+  userId?: string | number
+  channels: Set<string>
+  metadata: Record<string, any>
+}
+
+export interface WebSocketHandler {
+  /**
+   * Called before the WebSocket upgrade.
+   * Return a context object to allow the connection, or null to reject it.
+   */
+  onUpgrade(request: MantiqRequest): Promise<WebSocketContext | null>
+
+  open(ws: any): void | Promise<void>
+  message(ws: any, message: string | Buffer): void | Promise<void>
+  close(ws: any, code: number, reason: string): void | Promise<void>
+  drain(ws: any): void | Promise<void>
+}

package/src/websocket/WebSocketKernel.ts

@@ -0,0 +1,60 @@
+import type { WebSocketHandler } from './WebSocketContext.ts'
+import { MantiqRequest } from '../http/Request.ts'
+
+/**
+ * Handles WebSocket upgrade detection and lifecycle delegation.
+ *
+ * Core only provides the infrastructure — @mantiq/realtime registers
+ * its handler via registerHandler(). Without it, all upgrades return 426.
+ */
+export class WebSocketKernel {
+  private handler: WebSocketHandler | null = null
+
+  /**
+   * Called by @mantiq/realtime to register its WebSocket handler.
+   */
+  registerHandler(handler: WebSocketHandler): void {
+    this.handler = handler
+  }
+
+  /**
+   * Called by HttpKernel when an upgrade request is detected.
+   */
+  async handleUpgrade(request: Request, server: any): Promise<Response> {
+    if (!this.handler) {
+      return new Response('WebSocket not available. Install @mantiq/realtime.', {
+        status: 426,
+        headers: { Upgrade: 'websocket' },
+      })
+    }
+
+    const mantiqRequest = MantiqRequest.fromBun(request)
+    const context = await this.handler.onUpgrade(mantiqRequest)
+
+    if (!context) {
+      return new Response('Unauthorized', { status: 401 })
+    }
+
+    const upgraded = server.upgrade(request, { data: context })
+    if (!upgraded) {
+      return new Response('WebSocket upgrade failed', { status: 500 })
+    }
+
+    // Bun handles the response after a successful upgrade
+    return undefined as unknown as Response
+  }
+
+  /**
+   * Returns the Bun WebSocket handlers object for Bun.serve().
+   * If no handler is registered, provides no-op stubs.
+   */
+  getBunHandlers(): object {
+    const h = this.handler
+    return {
+      open: (ws: any) => h?.open(ws),
+      message: (ws: any, msg: any) => h?.message(ws, msg),
+      close: (ws: any, code: number, reason: string) => h?.close(ws, code, reason),
+      drain: (ws: any) => h?.drain(ws),
+    }
+  }
+}