npm - lopata - Versions diffs - 0.10.0 → 0.10.2 - Mend

lopata 0.10.0 → 0.10.2

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 (8) hide show

package/README.md +37 -0
package/dist/dashboard/{chunk-hnsny9g7.js → chunk-jpd3vqkt.js} +17 -1
package/dist/dashboard/index.html +1 -1
package/package.json +1 -1
package/src/api/handlers/routes.ts +1 -0
package/src/cli/dev.ts +19 -29
package/src/route-matcher.ts +26 -7
package/src/vite-plugin/dev-server-plugin.ts +21 -31

package/README.md CHANGED Viewed

@@ -198,6 +198,43 @@ export default {
 Workers can call each other via service bindings configured in their respective `wrangler.jsonc`. Both HTTP (`binding.fetch()`) and RPC (`binding.myMethod()`) modes are supported, including promise pipelining.
+### Route patterns
+In multi-worker setups, auxiliary workers can use Cloudflare-style `routes` in their `wrangler.jsonc` to handle specific URL patterns. The main worker acts as a fallback for unmatched requests.
+```jsonc
+// workers/api/wrangler.jsonc
+{
+	"name": "api-worker",
+	"main": "src/index.ts",
+	"routes": [
+		"example.com/api/*",
+		{ "pattern": "example.com/webhooks/*" }
+	]
+}
+```
+Routes support trailing `*` wildcards (`/api/*` matches `/api/foo` and `/api/foo/bar`). When multiple routes match, the most specific one wins (more path segments > fewer, exact match > wildcard). The domain portion is stripped — only the path is matched locally.
+### Host-based routing
+For routing by hostname (e.g. subdomains), use `hosts` in `lopata.config.ts`:
+```ts
+export default {
+	main: './wrangler.jsonc',
+	workers: [
+		{
+			name: 'api-worker',
+			config: './workers/api/wrangler.jsonc',
+			hosts: ['api.localhost', '*.api.localhost'],
+		},
+	],
+}
+```
+Wildcard patterns like `*.localhost` match any subdomain. Requests matching a host pattern are routed to that worker regardless of path-based routes.
 ## Vite plugin
 The Vite plugin is a drop-in replacement for `@cloudflare/vite-plugin`. It provides:

package/dist/dashboard/{chunk-hnsny9g7.js → chunk-jpd3vqkt.js} RENAMED Viewed

@@ -1168,8 +1168,24 @@ function CopyMarkdownButton({ getMarkdown, title }) {
     children: copied ? "Copied!" : "Copy MD"
   }, undefined, false, undefined, this);
 }
+function extractText(v3) {
+  if (v3 == null || v3 === false || v3 === true)
+    return "";
+  if (typeof v3 === "string" || typeof v3 === "number")
+    return String(v3);
+  if (Array.isArray(v3))
+    return v3.map(extractText).join("");
+  if (typeof v3 === "object" && "props" in v3) {
+    const vnode = v3;
+    if (typeof vnode.type === "function") {
+      return extractText(vnode.type(vnode.props));
+    }
+    return extractText(vnode.props.children);
+  }
+  return String(v3);
+}
 function tableToMarkdown(headers, rows) {
-  const escape = (v3) => String(v3 ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
+  const escape = (v3) => extractText(v3).replace(/\|/g, "\\|").replace(/\n/g, " ");
   const headerRow = `| ${headers.map(escape).join(" | ")} |`;
   const separator = `| ${headers.map(() => "---").join(" | ")} |`;
   const dataRows = rows.map((row) => `| ${row.map(escape).join(" | ")} |`);

package/dist/dashboard/index.html CHANGED Viewed

@@ -8,7 +8,7 @@
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet" />
-<link rel="stylesheet" crossorigin href="/__dashboard/assets/chunk-jzyhpjad.css"><script type="module" crossorigin src="/__dashboard/assets/chunk-hnsny9g7.js"></script></head>
+<link rel="stylesheet" crossorigin href="/__dashboard/assets/chunk-jzyhpjad.css"><script type="module" crossorigin src="/__dashboard/assets/chunk-jpd3vqkt.js"></script></head>
 <body class="h-full bg-surface text-ink" style="font-family: system-ui, -apple-system, sans-serif;">
   <script>
     // Apply saved theme before first paint to prevent flash

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "lopata",
-	"version": "0.10.0",
+	"version": "0.10.2",
 	"type": "module",
 	"license": "MIT",
 	"repository": {

package/src/api/handlers/routes.ts CHANGED Viewed

@@ -12,6 +12,7 @@ export const handlers = {
 		if (ctx.routeDispatcher) {
 			for (const r of ctx.routeDispatcher.getRegisteredRoutes()) {
+				if (r.hostPatterns) continue // already shown as host routes
 				routes.push({ pattern: r.pattern, workerName: r.workerName, isFallback: false })
 			}
 		}

package/src/cli/dev.ts CHANGED Viewed

@@ -22,7 +22,7 @@ import { FileWatcher } from '../file-watcher'
 import { GenerationManager } from '../generation-manager'
 import { loadLopataConfig } from '../lopata-config'
 import { addCfProperty } from '../request-cf'
-import { matchHost, RouteDispatcher } from '../route-matcher'
+import { extractHostname, RouteDispatcher } from '../route-matcher'
 import { getTraceStore } from '../tracing/store'
 import type { TraceEvent } from '../tracing/types'
 import { WorkerRegistry } from '../worker-registry'
@@ -43,7 +43,6 @@ export async function run(ctx: CliContext) {
 	let manager: GenerationManager
 	let routeDispatcher: RouteDispatcher | undefined
 	let registry: WorkerRegistry | undefined
-	const hostRoutes: Array<{ pattern: string; manager: GenerationManager; workerName: string }> = []
 	if (lopataConfig) {
 		// ─── Multi-worker mode ─────────────────────────────────────────
@@ -114,7 +113,7 @@ export async function run(ctx: CliContext) {
 					if (routeDispatcher) {
 						try {
 							const freshConfig = await loadConfig(workerDef.config, envFlag)
-							routeDispatcher.addRoutes(freshConfig, auxManager, workerDef.name)
+							routeDispatcher.addRoutes(freshConfig, auxManager, workerDef.name, workerDef.hosts)
 						} catch (err) {
 							console.warn(`[lopata] Failed to re-read config for "${workerDef.name}" routes:`, err)
 						}
@@ -139,32 +138,35 @@ export async function run(ctx: CliContext) {
 			)
 		}
-		// Build route dispatcher for route-based worker selection (aux workers only — main is the fallback)
+		// Build route dispatcher (aux workers only — main is the fallback)
 		routeDispatcher = new RouteDispatcher(mainManager)
 		for (const workerDef of lopataConfig.workers ?? []) {
-			const auxConfig = auxConfigs.get(workerDef.name)
 			const auxMgr = registry.getManager(workerDef.name)
-			if (auxConfig && auxMgr) routeDispatcher.addRoutes(auxConfig, auxMgr, workerDef.name)
+			if (!auxMgr) continue
+			const auxConfig = auxConfigs.get(workerDef.name)
+			if (auxConfig) routeDispatcher.addRoutes(auxConfig, auxMgr, workerDef.name, workerDef.hosts)
+			// Workers with hosts but no wrangler routes still need a catch-all entry
+			if (workerDef.hosts && (!auxConfig?.routes || auxConfig.routes.length === 0)) {
+				routeDispatcher.addHostWorker(auxMgr, workerDef.name, workerDef.hosts)
+			}
 		}
 		if (routeDispatcher.hasRoutes()) {
 			for (const r of routeDispatcher.getRegisteredRoutes()) {
-				console.log(`[lopata] Route: ${r.pattern} → ${r.workerName}`)
+				const hostInfo = r.hostPatterns ? ` (hosts: ${r.hostPatterns.join(', ')})` : ''
+				console.log(`[lopata] Route: ${r.pattern} → ${r.workerName}${hostInfo}`)
 			}
 		}
-		// Build host-based routing map
+		// Expose host routes to the dashboard API
+		const hostRoutes: Array<{ pattern: string; workerName: string }> = []
 		for (const workerDef of lopataConfig.workers ?? []) {
 			if (!workerDef.hosts) continue
-			const auxMgr = registry.getManager(workerDef.name)
-			if (!auxMgr) continue
 			for (const host of workerDef.hosts) {
-				hostRoutes.push({ pattern: host, manager: auxMgr, workerName: workerDef.name })
-				console.log(`[lopata] Host route: ${host} → ${workerDef.name}`)
+				hostRoutes.push({ pattern: host, workerName: workerDef.name })
 			}
 		}
 		if (hostRoutes.length > 0) {
-			setHostRoutes(hostRoutes.map(hr => ({ pattern: hr.pattern, workerName: hr.workerName })))
+			setHostRoutes(hostRoutes)
 		}
 		manager = mainManager
@@ -280,21 +282,9 @@ export async function run(ctx: CliContext) {
 				return gen.callScheduled(cronExpr)
 			}
-			// Host-based dispatch: match Host header against configured patterns
-			if (hostRoutes.length > 0) {
-				const hostHeader = request.headers.get('host') ?? ''
-				const hostname = hostHeader.split(':')[0] ?? ''
-				for (const hr of hostRoutes) {
-					if (matchHost(hostname, hr.pattern)) {
-						const gen = hr.manager.active
-						if (!gen) return new Response('No active generation', { status: 503 })
-						return (await gen.callFetch(request, server)) as Response
-					}
-				}
-			}
-			// Delegate to active generation (route-based dispatch in multi-worker mode)
-			const targetManager = routeDispatcher ? routeDispatcher.resolve(url.pathname) : manager
+			// Delegate to active generation (host + route dispatch in multi-worker mode)
+			const reqHostname = extractHostname(request.headers.get('host') ?? '')
+			const targetManager = routeDispatcher ? routeDispatcher.resolve(url.pathname, reqHostname) : manager
 			const gen = targetManager.active
 			if (!gen) {
 				return new Response('No active generation', { status: 503 })

package/src/route-matcher.ts CHANGED Viewed

@@ -61,6 +61,11 @@ export function matchRoute(pathname: string, pattern: string): boolean {
 	return pathname === pattern
 }
+/** Extract hostname from a Host header value, stripping the port if present. */
+export function extractHostname(hostHeader: string): string {
+	return hostHeader.split(':')[0] ?? ''
+}
 /** Match a hostname against a host pattern. Supports exact match and `*.domain` wildcards. */
 export function matchHost(hostname: string, pattern: string): boolean {
 	if (pattern === hostname) return true
@@ -83,6 +88,8 @@ interface RouteEntry {
 	pattern: string
 	workerName: string
 	manager: RoutableManager
+	/** When set, this route only matches requests whose hostname matches one of these patterns. */
+	hostPatterns?: string[]
 }
 /**
@@ -101,7 +108,7 @@ export class RouteDispatcher {
 		this.fallback = fallback
 	}
-	addRoutes(config: WranglerConfig, manager: RoutableManager, workerName: string): void {
+	addRoutes(config: WranglerConfig, manager: RoutableManager, workerName: string, hostPatterns?: string[]): void {
 		if (!config.routes) return
 		// Clear existing routes for this worker to support re-registration (e.g. config reload)
@@ -127,8 +134,8 @@ export class RouteDispatcher {
 				console.warn(`[lopata] Warning: route pattern "${pattern}" has a wildcard not at the end — Cloudflare only supports trailing wildcards`)
 			}
-			// Skip duplicate patterns from different workers (first registered wins)
-			const existing = this.routes.find(r => r.pattern === pattern)
+			// Skip duplicate patterns from different workers when they share the same host scope (first registered wins)
+			const existing = this.routes.find(r => r.pattern === pattern && !r.hostPatterns && !hostPatterns)
 			if (existing) {
 				console.warn(
 					`[lopata] Warning: route pattern "${pattern}" is already registered by "${existing.workerName}" — skipping duplicate from "${workerName}"`,
@@ -136,11 +143,19 @@ export class RouteDispatcher {
 				continue
 			}
-			this.routes.push({ pattern, workerName, manager })
+			this.routes.push({ pattern, workerName, manager, hostPatterns })
 			this.sorted = false
 		}
 	}
+	/** Register a worker that handles all paths for the given host patterns (no wrangler routes needed). */
+	addHostWorker(manager: RoutableManager, workerName: string, hostPatterns: string[]): void {
+		// Clear existing routes for this worker to support re-registration
+		this.routes = this.routes.filter(r => r.workerName !== workerName)
+		this.routes.push({ pattern: '/*', workerName, manager, hostPatterns })
+		this.sorted = false
+	}
 	removeWorkerRoutes(workerName: string): void {
 		this.routes = this.routes.filter(r => r.workerName !== workerName)
 	}
@@ -166,9 +181,13 @@ export class RouteDispatcher {
 		this.sorted = true
 	}
-	resolve(pathname: string): RoutableManager {
+	resolve(pathname: string, hostname?: string): RoutableManager {
 		this.ensureSorted()
 		for (const entry of this.routes) {
+			// If route has host constraints, skip unless hostname matches one of them
+			if (entry.hostPatterns) {
+				if (hostname === undefined || !entry.hostPatterns.some(hp => matchHost(hostname, hp))) continue
+			}
 			if (matchRoute(pathname, entry.pattern)) {
 				return entry.manager
 			}
@@ -185,8 +204,8 @@ export class RouteDispatcher {
 		return this.routes.length > 0
 	}
-	getRegisteredRoutes(): Array<{ pattern: string; workerName: string }> {
+	getRegisteredRoutes(): Array<{ pattern: string; workerName: string; hostPatterns?: string[] }> {
 		this.ensureSorted()
-		return this.routes.map(r => ({ pattern: r.pattern, workerName: r.workerName }))
+		return this.routes.map(r => ({ pattern: r.pattern, workerName: r.workerName, hostPatterns: r.hostPatterns }))
 	}
 }

package/src/vite-plugin/dev-server-plugin.ts CHANGED Viewed

@@ -3,7 +3,7 @@ import { dirname, resolve } from 'node:path'
 import type { Plugin, ViteDevServer } from 'vite'
 import { FileWatcher } from '../file-watcher.ts'
 import type { RoutableManager } from '../route-matcher.ts'
-import { matchHost, RouteDispatcher } from '../route-matcher.ts'
+import { extractHostname, RouteDispatcher } from '../route-matcher.ts'
 interface DevServerPluginOptions {
 	configPath?: string
@@ -53,8 +53,6 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	// Route dispatcher for multi-worker route-based dispatching
 	let routeDispatcher: RouteDispatcher | undefined
-	// Host-based routing: map host patterns to managers
-	const hostRoutes: Array<{ pattern: string; manager: RoutableManager; workerName: string }> = []
 	// Track current module to detect when Vite HMR invalidates it
 	let currentModule: Record<string, unknown> | null = null
@@ -208,27 +206,15 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	/**
 	 * Resolve an auxiliary worker for the given request.
-	 * Checks host-based routes first, then path-based route dispatcher.
 	 * Returns null if the request should be handled by the main worker.
 	 */
 	function resolveAuxWorker(req: IncomingMessage, url: string): { manager: RoutableManager; workerName: string } | null {
-		// Host-based dispatch
-		if (hostRoutes.length > 0) {
-			const hostHeader = req.headers.host ?? ''
-			const hostname = hostHeader.split(':')[0] ?? ''
-			for (const hr of hostRoutes) {
-				if (matchHost(hostname, hr.pattern)) {
-					return hr
-				}
-			}
-		}
-		// Path-based dispatch
-		if (routeDispatcher) {
-			const parsedUrl = new URL(url, 'http://localhost')
-			const targetManager = routeDispatcher.resolve(parsedUrl.pathname)
-			if (!routeDispatcher.isFallback(targetManager)) {
-				return { manager: targetManager, workerName: (targetManager as any).config?.name ?? 'aux' }
-			}
+		if (!routeDispatcher) return null
+		const parsedUrl = new URL(url, 'http://localhost')
+		const hostname = extractHostname(req.headers.host ?? '')
+		const targetManager = routeDispatcher.resolve(parsedUrl.pathname, hostname)
+		if (!routeDispatcher.isFallback(targetManager)) {
+			return { manager: targetManager, workerName: (targetManager as any).config?.name ?? 'aux' }
 		}
 		return null
 	}
@@ -415,7 +401,7 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 							if (routeDispatcher) {
 								try {
 									const freshConfig = await configMod.loadConfig(auxConfigPath)
-									routeDispatcher.addRoutes(freshConfig, auxManager, workerName)
+									routeDispatcher.addRoutes(freshConfig, auxManager, workerName, workerDef.hosts)
 								} catch (err) {
 									console.warn(`[lopata:vite] Failed to re-read config for "${workerName}" routes:`, err)
 								}
@@ -437,35 +423,39 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 					)
 				}
-				// Build route dispatcher for aux workers with routes (main worker is the fallback)
+				// Build route dispatcher (aux workers only — main is the fallback)
 				routeDispatcher = new RouteDispatcher(mainAdapter)
 				for (const workerDef of options.auxiliaryWorkers) {
 					const cached = auxConfigs.get(workerDef.configPath)
 					if (!cached) continue
 					const auxMgr = workerRegistry.getManager(cached.name)
-					if (auxMgr) routeDispatcher.addRoutes(cached.config, auxMgr, cached.name)
+					if (!auxMgr) continue
+					routeDispatcher.addRoutes(cached.config, auxMgr, cached.name, workerDef.hosts)
+					// Workers with hosts but no wrangler routes still need a catch-all entry
+					if (workerDef.hosts && (!cached.config.routes || cached.config.routes.length === 0)) {
+						routeDispatcher.addHostWorker(auxMgr, cached.name, workerDef.hosts)
+					}
 				}
 				if (routeDispatcher.hasRoutes()) {
 					for (const r of routeDispatcher.getRegisteredRoutes()) {
-						console.log(`[lopata:vite] Route: ${r.pattern} → ${r.workerName}`)
+						const hostInfo = r.hostPatterns ? ` (hosts: ${r.hostPatterns.join(', ')})` : ''
+						console.log(`[lopata:vite] Route: ${r.pattern} → ${r.workerName}${hostInfo}`)
 					}
 				}
 				apiMod.setRouteDispatcher(routeDispatcher)
-				// Build host-based routing map
+				// Expose host routes to the dashboard API
+				const hostRoutes: Array<{ pattern: string; workerName: string }> = []
 				for (const workerDef of options.auxiliaryWorkers) {
 					if (!workerDef.hosts) continue
 					const cached = auxConfigs.get(workerDef.configPath)
 					if (!cached) continue
-					const auxMgr = workerRegistry.getManager(cached.name)
-					if (!auxMgr) continue
 					for (const host of workerDef.hosts) {
-						hostRoutes.push({ pattern: host, manager: auxMgr, workerName: cached.name })
-						console.log(`[lopata:vite] Host route: ${host} → ${cached.name}`)
+						hostRoutes.push({ pattern: host, workerName: cached.name })
 					}
 				}
 				if (hostRoutes.length > 0) {
-					apiMod.setHostRoutes(hostRoutes.map(hr => ({ pattern: hr.pattern, workerName: hr.workerName })))
+					apiMod.setHostRoutes(hostRoutes)
 				}
 			}