@strav/http 0.2.4 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strav/http",
-  "version": "0.2.4",
+  "version": "0.2.7",
   "type": "module",
   "description": "HTTP layer for the Strav framework — router, server, middleware, authentication, sessions, validation, and views",
   "license": "MIT",
@@ -19,6 +19,7 @@
   ],
   "exports": {
     ".": "./src/index.ts",
+    "./client": "./src/client/index.ts",
     "./http": "./src/http/index.ts",
     "./http/*": "./src/http/*.ts",
     "./view": "./src/view/index.ts",
@@ -35,8 +36,8 @@
     "./providers/*": "./src/providers/*.ts"
   },
   "peerDependencies": {
-    "@strav/kernel": "0.1.4",
-    "@strav/database": "0.1.4"
+    "@strav/kernel": "0.2.6",
+    "@strav/database": "0.2.6"
   },
   "dependencies": {
     "@vue/compiler-sfc": "^3.5.28",

package/src/auth/middleware/guest.ts

@@ -27,7 +27,7 @@ export function guest(redirectTo?: string): Middleware {
 
     if (guardName === 'session') {
       const session = ctx.get<Session>('session')
-      isAuthenticated = session !== null && session.isAuthenticated && !session.isExpired()
+      isAuthenticated = session && session.isAuthenticated && !session.isExpired()
     } else if (guardName === 'token') {
       const header = ctx.header('authorization')
       if (header?.startsWith('Bearer ')) {

package/src/client/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Browser-safe HTTP utilities from @strav/http
+ *
+ * This module exports only browser-compatible functionality,
+ * avoiding Node.js dependencies that cause bundling issues.
+ *
+ * @example
+ * ```typescript
+ * import { route, routeUrl } from '@strav/http/client'
+ *
+ * // Use route helpers on the client-side
+ * const response = await route('users.show', { params: { id: 123 } })
+ * const profileUrl = routeUrl('users.profile', { id: 456 })
+ * ```
+ */
+
+// Re-export browser-safe route helpers (no Node.js dependencies)
+export { route, routeUrl, registerRoutes } from './route_helper.ts'
+export type { RouteOptions } from './route_helper.ts'
+
+// Re-export browser-safe types
+export type {
+  Handler,
+  Middleware,
+  Next
+} from '../http/middleware.ts'
+
+export type {
+  CorsOptions
+} from '../http/cors.ts'
+
+export type {
+  CookieOptions
+} from '../http/cookie.ts'
+
+export type {
+  RouteDefinition,
+  GroupOptions,
+  WebSocketHandlers,
+  WebSocketData
+} from '../http/router.ts'

package/src/client/route_helper.ts

@@ -0,0 +1,181 @@
+/**
+ * Browser-safe route helpers that work without the server-side router instance.
+ *
+ * These functions maintain the same API as the server-side route helpers but
+ * require route definitions to be provided at runtime or fallback to URL construction.
+ */
+
+export interface RouteOptions extends Omit<RequestInit, 'body'> {
+  params?: Record<string, any>
+  body?: any
+}
+
+// Global registry for client-side route definitions
+const clientRoutes = new Map<string, { method: string; pattern: string }>()
+
+/**
+ * Register route definitions for client-side use.
+ * This should be called during app initialization with route data from the server.
+ */
+export function registerRoutes(routes: Record<string, { method: string; pattern: string }>) {
+  Object.entries(routes).forEach(([name, def]) => {
+    clientRoutes.set(name, def)
+  })
+}
+
+/**
+ * Generate a URL for a named route with optional parameters.
+ *
+ * @example
+ * const profileUrl = routeUrl('users.profile', { id: 456 })
+ * // Returns '/users/456'
+ */
+export function routeUrl(name: string, params?: Record<string, any>): string {
+  const routeDef = clientRoutes.get(name)
+  if (!routeDef) {
+    throw new Error(`Route '${name}' not found. Make sure to call registerRoutes() with route definitions.`)
+  }
+
+  return generateUrl(routeDef.pattern, params)
+}
+
+/**
+ * Invoke a named route with automatic method detection and smart defaults.
+ *
+ * @example
+ * // Simple POST with JSON body
+ * await route('auth.register', {
+ *   name: 'John',
+ *   email: 'john@example.com',
+ *   password: 'secret'
+ * })
+ *
+ * // GET with URL parameters
+ * await route('users.show', { params: { id: 123 } })
+ */
+export async function route(
+  name: string,
+  data?: any,
+  options?: RouteOptions
+): Promise<Response> {
+  const routeDef = clientRoutes.get(name)
+  if (!routeDef) {
+    throw new Error(`Route '${name}' not found. Make sure to call registerRoutes() with route definitions.`)
+  }
+
+  // Determine if data is the body or options
+  let body: any
+  let opts: RouteOptions = {}
+
+  if (data !== undefined) {
+    // If data has params, body, or any RequestInit properties, treat it as options
+    if (
+      typeof data === 'object' &&
+      !Array.isArray(data) &&
+      !(data instanceof FormData) &&
+      !(data instanceof Blob) &&
+      !(data instanceof ArrayBuffer) &&
+      !(data instanceof URLSearchParams) &&
+      ('params' in data || 'body' in data || 'headers' in data || 'cache' in data ||
+       'credentials' in data || 'mode' in data || 'redirect' in data || 'referrer' in data)
+    ) {
+      opts = data
+      body = opts.body
+    } else {
+      // Otherwise, treat data as the body
+      body = data
+      opts = options || {}
+    }
+  } else {
+    opts = options || {}
+  }
+
+  // Generate URL with parameters
+  const generatedUrl = generateUrl(routeDef.pattern, opts.params)
+
+  // Determine method from route definition
+  const method = opts.method || routeDef.method
+
+  // Build headers with smart defaults
+  const headers = new Headers(opts.headers)
+
+  // Set default Accept header if not provided
+  if (!headers.has('Accept')) {
+    headers.set('Accept', 'application/json')
+  }
+
+  // Handle body and Content-Type
+  let requestBody: string | FormData | Blob | ArrayBuffer | URLSearchParams | undefined
+  if (body !== undefined && method !== 'GET' && method !== 'HEAD') {
+    if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || body instanceof URLSearchParams) {
+      // Let fetch set the Content-Type for FormData, or use the existing type for Blob/ArrayBuffer
+      requestBody = body
+    } else if (typeof body === 'object') {
+      // JSON body
+      if (!headers.has('Content-Type')) {
+        headers.set('Content-Type', 'application/json')
+      }
+      requestBody = JSON.stringify(body)
+    } else {
+      // String or other primitive
+      requestBody = String(body)
+      if (!headers.has('Content-Type')) {
+        headers.set('Content-Type', 'text/plain')
+      }
+    }
+  }
+
+  // Set default credentials if not provided
+  const credentials = opts.credentials || 'same-origin'
+
+  // Build final fetch options
+  const fetchOptions: RequestInit = {
+    ...opts,
+    method,
+    headers,
+    credentials,
+    ...(requestBody !== undefined && { body: requestBody })
+  }
+
+  // Remove our custom properties
+  delete (fetchOptions as any).params
+
+  return fetch(generatedUrl, fetchOptions)
+}
+
+/**
+ * Generate URL from pattern and parameters (browser-safe version)
+ */
+function generateUrl(pattern: string, params?: Record<string, any>): string {
+  let url = pattern
+  const queryParams: Record<string, string> = {}
+
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      const paramPattern = `:${key}`
+      const wildcardPattern = `*${key}`
+
+      if (url.includes(paramPattern)) {
+        // Replace route parameter
+        url = url.replace(paramPattern, encodeURIComponent(String(value)))
+      } else if (url.includes(wildcardPattern)) {
+        // Replace wildcard parameter
+        url = url.replace(`/${wildcardPattern}`, `/${encodeURIComponent(String(value))}`)
+      } else {
+        // Add as query parameter
+        queryParams[key] = String(value)
+      }
+    })
+  }
+
+  // Append query parameters
+  const queryString = Object.keys(queryParams)
+    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(queryParams[key] ?? '')}`)
+    .join('&')
+
+  if (queryString) {
+    url += (url.includes('?') ? '&' : '?') + queryString
+  }
+
+  return url
+}

package/src/http/router.ts

@@ -446,6 +446,17 @@ export default class Router {
     return this.routes.find(route => route.name === name)
   }
 
+  /**
+   * Get all registered routes.
+   *
+   * @example
+   * const routes = router.getAllRoutes()
+   * // Returns array of all route definitions
+   */
+  getAllRoutes(): readonly RouteDefinition[] {
+    return this.routes
+  }
+
   /**
    * Generate a URL for a named route with optional parameters.
    *

package/src/index.ts

@@ -1,5 +1,4 @@
 export * from './http/index.ts'
-export * from './view/index.ts'
 export * from './session/index.ts'
 export * from './validation/index.ts'
 export * from './policy/index.ts'

package/src/view/cache.ts

@@ -1,47 +0,0 @@
-export interface RenderResult {
-  output: string
-  blocks: Record<string, string>
-}
-
-export type RenderFunction = (
-  data: Record<string, unknown>,
-  includeFn: IncludeFn
-) => Promise<RenderResult>
-
-export type IncludeFn = (name: string, data: Record<string, unknown>) => Promise<string>
-
-export interface CacheEntry {
-  fn: RenderFunction
-  layout?: string
-  mtime: number
-  filePath: string
-}
-
-export default class TemplateCache {
-  private entries = new Map<string, CacheEntry>()
-
-  get(name: string): CacheEntry | undefined {
-    return this.entries.get(name)
-  }
-
-  set(name: string, entry: CacheEntry): void {
-    this.entries.set(name, entry)
-  }
-
-  async isStale(name: string): Promise<boolean> {
-    const entry = this.entries.get(name)
-    if (!entry) return true
-    const file = Bun.file(entry.filePath)
-    const exists = await file.exists()
-    if (!exists) return true
-    return file.lastModified > entry.mtime
-  }
-
-  delete(name: string): void {
-    this.entries.delete(name)
-  }
-
-  clear(): void {
-    this.entries.clear()
-  }
-}

package/src/view/client/islands.ts

@@ -1,84 +0,0 @@
-// @ts-nocheck — Client-side script; requires DOM types provided by the app's bundler config.
-/**
- * Vue Islands Bootstrap
- *
- * Auto-discovers elements with [data-vue] attributes and mounts
- * Vue components on them via a single shared Vue app instance.
- * All islands share the same app context (plugins, provide/inject,
- * global components), connected to their marker elements via Teleport.
- *
- * Register your components on the window before this script runs:
- *
- *   import Counter from './components/Counter.vue'
- *   window.__vue_components = { counter: Counter }
- *
- * Optionally provide a setup function to install plugins:
- *
- *   window.__vue_setup = (app) => {
- *     app.use(somePlugin)
- *     app.provide('key', value)
- *   }
- *
- * Then in your .strav templates:
- *   <vue:counter :initial="{{ count }}" label="Click me" />
- */
-
-import { createApp, defineComponent, h, Teleport } from 'vue'
-
-declare global {
-  interface Window {
-    __vue_components?: Record<string, any>
-    __vue_setup?: (app: any) => void
-  }
-}
-
-function toPascalCase(str: string): string {
-  return str.replace(/(^|-)(\w)/g, (_match, _sep, char) => char.toUpperCase())
-}
-
-function mountIslands(): void {
-  const components = window.__vue_components ?? {}
-
-  const islands: { Component: any; props: Record<string, any>; el: HTMLElement }[] = []
-
-  document.querySelectorAll<HTMLElement>('[data-vue]').forEach(el => {
-    const name = el.dataset.vue
-    if (!name) return
-
-    const Component = components[name] ?? components[toPascalCase(name)]
-    if (!Component) {
-      console.warn(`[islands] Unknown component: ${name}`)
-      return
-    }
-
-    const props = JSON.parse(el.dataset.props ?? '{}')
-    islands.push({ Component, props, el })
-  })
-
-  if (islands.length === 0) return
-
-  const Root = defineComponent({
-    render() {
-      return islands.map(island =>
-        h(Teleport, { to: island.el }, [h(island.Component, island.props)])
-      )
-    },
-  })
-
-  const app = createApp(Root)
-
-  if (typeof window.__vue_setup === 'function') {
-    window.__vue_setup(app)
-  }
-
-  const root = document.createElement('div')
-  root.style.display = 'contents'
-  document.body.appendChild(root)
-  app.mount(root)
-}
-
-if (document.readyState === 'loading') {
-  document.addEventListener('DOMContentLoaded', mountIslands)
-} else {
-  mountIslands()
-}

package/src/view/compiler.ts

@@ -1,199 +0,0 @@
-import { TemplateError } from '@strav/kernel/exceptions/errors'
-import type { Token } from './tokenizer.ts'
-
-export interface CompilationResult {
-  code: string
-  layout?: string
-}
-
-interface StackEntry {
-  type: 'if' | 'each' | 'block'
-  line: number
-  blockName?: string
-}
-
-function escapeJs(str: string): string {
-  return str
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, '\\n')
-    .replace(/\r/g, '\\r')
-    .replace(/\t/g, '\\t')
-}
-
-export function compile(tokens: Token[]): CompilationResult {
-  const lines: string[] = []
-  const stack: StackEntry[] = []
-  let layout: string | undefined
-
-  lines.push('let __out = "";')
-  lines.push('const __blocks = {};')
-
-  for (const token of tokens) {
-    switch (token.type) {
-      case 'text':
-        lines.push(`__out += "${escapeJs(token.value)}";`)
-        break
-
-      case 'escaped':
-        lines.push(`__out += __escape(${token.value});`)
-        break
-
-      case 'raw':
-        lines.push(`__out += (${token.value});`)
-        break
-
-      case 'comment':
-        // Stripped from output
-        break
-
-      case 'vue_island': {
-        const attrs = token.attrs ?? {}
-        const propParts: string[] = []
-        for (const [name, attr] of Object.entries(attrs)) {
-          if (attr.bound) {
-            propParts.push(`${JSON.stringify(name)}: (${attr.value})`)
-          } else {
-            propParts.push(`${JSON.stringify(name)}: ${JSON.stringify(attr.value)}`)
-          }
-        }
-        const propsExpr = `{${propParts.join(', ')}}`
-        const tag = escapeJs(token.tag!)
-        lines.push('__out += \'<div data-vue="' + tag + '"\'')
-        lines.push(
-          '  + " data-props=\'" + JSON.stringify(' + propsExpr + ").replace(/'/g, '&#39;') + \"'\""
-        )
-        lines.push("  + '></div>';")
-
-        break
-      }
-
-      case 'directive':
-        compileDirective(token, lines, stack, l => {
-          layout = l
-        })
-        break
-    }
-  }
-
-  if (stack.length > 0) {
-    const unclosed = stack[stack.length - 1]!
-    throw new TemplateError(`Unclosed @${unclosed.type} block (opened at line ${unclosed.line})`)
-  }
-
-  lines.push('return { output: __out, blocks: __blocks };')
-
-  return { code: lines.join('\n'), layout }
-}
-
-function compileDirective(
-  token: Token,
-  lines: string[],
-  stack: StackEntry[],
-  setLayout: (name: string) => void
-): void {
-  switch (token.directive) {
-    case 'if':
-      if (!token.args) throw new TemplateError(`@if requires a condition at line ${token.line}`)
-      lines.push(`if (${token.args}) {`)
-      stack.push({ type: 'if', line: token.line })
-      break
-
-    case 'elseif':
-      if (!token.args) throw new TemplateError(`@elseif requires a condition at line ${token.line}`)
-      if (!stack.length || stack[stack.length - 1]!.type !== 'if') {
-        throw new TemplateError(`@elseif without matching @if at line ${token.line}`)
-      }
-      lines.push(`} else if (${token.args}) {`)
-      break
-
-    case 'else':
-      if (!stack.length || stack[stack.length - 1]!.type !== 'if') {
-        throw new TemplateError(`@else without matching @if at line ${token.line}`)
-      }
-      lines.push(`} else {`)
-      break
-
-    case 'each': {
-      if (!token.args) throw new TemplateError(`@each requires arguments at line ${token.line}`)
-      const match = token.args.match(/^\s*(\w+)\s+in\s+(.+)$/)
-      if (!match) {
-        throw new TemplateError(`@each syntax error at line ${token.line}: expected "item in list"`)
-      }
-      const itemName = match[1]!
-      const listExpr = match[2]!.trim()
-      lines.push(`{`)
-      lines.push(`  const __list = (${listExpr});`)
-      lines.push(`  for (let $index = 0; $index < __list.length; $index++) {`)
-      lines.push(`    const ${itemName} = __list[$index];`)
-      lines.push(`    const $first = $index === 0;`)
-      lines.push(`    const $last = $index === __list.length - 1;`)
-      stack.push({ type: 'each', line: token.line })
-      break
-    }
-
-    case 'layout': {
-      if (!token.args) throw new TemplateError(`@layout requires a name at line ${token.line}`)
-      const name = token.args.replace(/^['"]|['"]$/g, '').trim()
-      setLayout(name)
-      break
-    }
-
-    case 'block': {
-      if (!token.args) throw new TemplateError(`@block requires a name at line ${token.line}`)
-      const name = token.args.replace(/^['"]|['"]$/g, '').trim()
-      const nameStr = JSON.stringify(name)
-      // If a child template already provided this block as data, yield it.
-      // Otherwise, render the default content between @block and @end.
-      lines.push(`if (typeof ${name} !== 'undefined' && ${name} !== null) {`)
-      lines.push(`  __out += ${name};`)
-      lines.push(`  __blocks[${nameStr}] = ${name};`)
-      lines.push(`} else {`)
-      lines.push(`  __blocks[${nameStr}] = (function() { let __out = "";`)
-      stack.push({ type: 'block', line: token.line, blockName: name })
-      break
-    }
-
-    case 'include': {
-      if (!token.args) throw new TemplateError(`@include requires arguments at line ${token.line}`)
-      const match = token.args.match(/^\s*['"]([^'"]+)['"]\s*(?:,\s*(.+))?\s*$/)
-      if (!match) {
-        throw new TemplateError(
-          `@include syntax error at line ${token.line}: expected "'name'" or "'name', data"`
-        )
-      }
-      const name = match[1]!
-      const dataExpr = match[2] ? match[2].trim() : '{}'
-      lines.push(`__out += await __include(${JSON.stringify(name)}, ${dataExpr});`)
-      break
-    }
-
-    case 'islands': {
-      const src = token.args ? token.args.replace(/^['"]|['"]$/g, '').trim() : '/islands.js'
-      // Use __islandsSrc (set by IslandBuilder via ViewEngine.setGlobal) for versioned URL, fallback to static src
-      lines.push(
-        `__out += '<script src="' + (typeof __islandsSrc !== 'undefined' ? __islandsSrc : '${escapeJs(src)}') + '"><\\/script>';`
-      )
-      break
-    }
-
-    case 'end': {
-      if (!stack.length) {
-        throw new TemplateError(`Unexpected @end at line ${token.line} — no open block`)
-      }
-      const top = stack.pop()!
-      if (top.type === 'block') {
-        const nameStr = JSON.stringify(top.blockName!)
-        lines.push(`  return __out; })();`)
-        lines.push(`  __out += __blocks[${nameStr}];`)
-        lines.push(`}`)
-      } else if (top.type === 'each') {
-        lines.push(`  }`) // close for loop
-        lines.push(`}`) // close block scope
-      } else {
-        lines.push(`}`)
-      }
-      break
-    }
-  }
-}