@openworkers/adapter-sveltekit 0.3.4 → 0.3.6

package/README.md

@@ -35,10 +35,10 @@ export default {
 
 ```
 dist/
-├── worker.js     # Main SSR worker
-├── routes.js     # Route manifest for edge routing
-├── assets/       # Static assets and prerendered pages
-└── functions/    # Mini-workers for API routes (if functions: true)
+├── _worker.js     # Main SSR worker
+├── _routes.json   # Route manifest for edge routing
+├── assets/        # Static assets and prerendered pages
+└── functions/     # Mini-workers for API routes (if functions: true)
     ├── api-hello.js
     └── api-users.js
 ```
@@ -50,7 +50,7 @@ When `functions: true`, the adapter generates a separate mini-worker for each `+
 - `/api/hello/+server.ts` → `functions/api-hello.js`
 - `/api/users/+server.ts` → `functions/api-users.js`
 
-The route mappings are included in `routes.js`:
+The route mappings are included in `_routes.json`:
 
 ```js
 {

package/files/function-worker.js

@@ -5,42 +5,86 @@
 
 import * as handlers from 'ENDPOINT';
 
+/**
+ * Extract route params from URL pathname based on SvelteKit route pattern
+ * @param {string} pathname - URL pathname (e.g., "/stream/42")
+ * @param {string} pattern - SvelteKit route pattern (e.g., "/stream/[n]")
+ * @returns {Record<string, string>} - Extracted params (e.g., {n: "42"})
+ */
+function extractParams(pathname, pattern) {
+  const params = {};
+  const patternSegments = pattern.split('/').filter(Boolean);
+  const pathSegments = pathname.split('/').filter(Boolean);
+
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSegment = patternSegments[i];
+
+    // Rest parameter: [...rest]
+    if (patternSegment.startsWith('[...') && patternSegment.endsWith(']')) {
+      const paramName = patternSegment.slice(4, -1);
+      params[paramName] = pathSegments.slice(i).join('/');
+      break;
+    }
+
+    // Optional parameter: [[optional]]
+    if (patternSegment.startsWith('[[') && patternSegment.endsWith(']]')) {
+      const paramName = patternSegment.slice(2, -2);
+      if (i < pathSegments.length) {
+        params[paramName] = pathSegments[i];
+      }
+      continue;
+    }
+
+    // Regular parameter: [param]
+    if (patternSegment.startsWith('[') && patternSegment.endsWith(']')) {
+      const paramName = patternSegment.slice(1, -1);
+      params[paramName] = pathSegments[i];
+      continue;
+    }
+  }
+
+  return params;
+}
+
 export default {
-	async fetch(req, env, ctx) {
-		globalThis.env = env;
-
-		const method = req.method;
-		const handler = handlers[method];
-
-		if (!handler) {
-			return new Response('Method Not Allowed', {
-				status: 405,
-				headers: { Allow: Object.keys(handlers).join(', ') }
-			});
-		}
-
-		const url = new URL(req.url);
-
-		// Build a minimal RequestEvent-like object
-		const event = {
-			request: req,
-			url,
-			params: ctx.params ?? {},
-			platform: { env, ctx },
-			getClientAddress() {
-				return req.headers.get('x-real-ip') ?? req.headers.get('x-forwarded-for') ?? '';
-			}
-		};
-
-		try {
-			return await handler(event);
-		} catch (error) {
-			console.error(`[Function] Error in ${method} handler:`, error);
-
-			return new Response(JSON.stringify({ error: 'Internal Server Error' }), {
-				status: 500,
-				headers: { 'Content-Type': 'application/json' }
-			});
-		}
-	}
+  async fetch(req, env, ctx) {
+    globalThis.env = env;
+
+    const method = req.method;
+    const handler = handlers[method];
+
+    if (!handler) {
+      return new Response('Method Not Allowed', {
+        status: 405,
+        headers: { Allow: Object.keys(handlers).join(', ') }
+      });
+    }
+
+    const url = new URL(req.url);
+
+    // Extract params from URL based on route pattern
+    const params = extractParams(url.pathname, ROUTE_PATTERN);
+
+    // Build a minimal RequestEvent-like object
+    const event = {
+      request: req,
+      url,
+      params,
+      platform: { env, ctx },
+      getClientAddress() {
+        return req.headers.get('x-real-ip') ?? req.headers.get('x-forwarded-for') ?? '';
+      }
+    };
+
+    try {
+      return await handler(event);
+    } catch (error) {
+      console.error(`[Function] Error in ${method} handler:`, error);
+
+      return new Response(JSON.stringify({ error: 'Internal Server Error' }), {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+  }
 };

package/files/shims/async_hooks.js

@@ -6,36 +6,36 @@
  */
 
 export class AsyncLocalStorage {
-	#store;
-
-	run(store, fn, ...args) {
-		this.#store = store;
-		return fn(...args);
-	}
-
-	getStore() {
-		return this.#store;
-	}
-
-	// Stubs for API completeness
-	enterWith(store) {
-		this.#store = store;
-	}
-
-	exit(fn, ...args) {
-		this.#store = undefined;
-		return fn(...args);
-	}
-
-	disable() {
-		this.#store = undefined;
-	}
-
-	static bind(fn) {
-		return fn;
-	}
-
-	static snapshot() {
-		return (fn, ...args) => fn(...args);
-	}
+  #store;
+
+  run(store, fn, ...args) {
+    this.#store = store;
+    return fn(...args);
+  }
+
+  getStore() {
+    return this.#store;
+  }
+
+  // Stubs for API completeness
+  enterWith(store) {
+    this.#store = store;
+  }
+
+  exit(fn, ...args) {
+    this.#store = undefined;
+    return fn(...args);
+  }
+
+  disable() {
+    this.#store = undefined;
+  }
+
+  static bind(fn) {
+    return fn;
+  }
+
+  static snapshot() {
+    return (fn, ...args) => fn(...args);
+  }
 }

package/index.js

@@ -91,15 +91,18 @@ export default function (options = {}) {
       if (functionsEnabled) {
         builder.mkdirp(`${dest}/functions`);
 
-        const endpointsDir = path.join(builder.getServerDirectory(), 'entries/endpoints');
+        const serverDir = builder.getServerDirectory();
+        const viteManifestPath = path.join(serverDir, '.vite/manifest.json');
         const functionTemplate = posixify(path.resolve(files, 'function-worker.js'));
 
-        if (existsSync(endpointsDir)) {
-          const endpoints = findEndpoints(endpointsDir);
+        if (existsSync(viteManifestPath)) {
+          const viteManifest = JSON.parse(readFileSync(viteManifestPath, 'utf-8'));
+          const endpoints = extractEndpointsFromManifest(viteManifest, serverDir);
 
           for (const endpoint of endpoints) {
-            const routePattern = endpoint.route;
-            const workerName = routePattern.replace(/\//g, '-').replace(/^-/, '') || 'index';
+            const routePattern = endpoint.pattern;
+            // Use SvelteKit route syntax for worker filename
+            const workerName = endpoint.route.replace(/\//g, '-').replace(/^-/, '') || 'index';
             const workerFile = `functions/${workerName}.js`;
 
             // Bundle using the template with ENDPOINT alias
@@ -115,6 +118,9 @@ export default function (options = {}) {
               },
               external: ['node:*'],
               minify: false,
+              define: {
+                ROUTE_PATTERN: JSON.stringify(endpoint.route)
+              },
               banner: {
                 js: `// Generated by ${name} v${version} - Function: ${routePattern}\n`
               }
@@ -162,30 +168,72 @@ export default function (options = {}) {
 }
 
 /**
- * Find all endpoint files in the server output
- * @param {string} dir
- * @param {string} [base='']
- * @returns {Array<{route: string, file: string}>}
+ * Extract endpoints from Vite manifest and convert SvelteKit routes to simple patterns
+ * @param {object} manifest - Vite manifest object
+ * @param {string} serverDir - Server build directory
+ * @returns {Array<{pattern: string, route: string, file: string}>}
  */
-function findEndpoints(dir, base = '') {
-  const results = [];
-  const entries = readdirSync(dir);
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry);
-    const stat = statSync(fullPath);
-
-    if (stat.isDirectory()) {
-      results.push(...findEndpoints(fullPath, `${base}/${entry}`));
-    } else if (entry === '_server.ts.js' || entry === '_server.js.js') {
-      results.push({
-        route: base || '/',
-        file: fullPath
-      });
-    }
+function extractEndpointsFromManifest(manifest, serverDir) {
+  const endpoints = [];
+
+  for (const [key, entry] of Object.entries(manifest)) {
+    // Only process endpoint files (+server.ts)
+    if (!key.includes('+server.ts')) continue;
+
+    const sourcePath = entry.src;
+    if (!sourcePath || !sourcePath.startsWith('src/routes/')) continue;
+
+    // Extract route from source path: src/routes/status/[code]/[[reason]]/+server.ts
+    const routePart = sourcePath
+      .replace(/^src\/routes/, '')
+      .replace(/\/\+server\.(ts|js)$/, '');
+
+    // Convert SvelteKit route syntax to simple wildcard patterns
+    const pattern = convertRouteToPattern(routePart);
+
+    // Get the built file path
+    const file = path.join(serverDir, entry.file);
+
+    endpoints.push({
+      pattern,       // For routing: /status/*/*
+      route: routePart,  // For filename: /status/[code]/[[reason]]
+      file
+    });
   }
 
-  return results;
+  return endpoints;
+}
+
+/**
+ * Convert SvelteKit route syntax to simple wildcard patterns
+ * Examples:
+ *   /status/[code]/[[reason]] becomes /status/star/star
+ *   /range/[n] becomes /range/star
+ *   /drip/[...params] becomes /drip/doublestar
+ * @param {string} route - SvelteKit route (e.g. "/status/[code]/[[reason]]")
+ * @returns {string} - Simple pattern with wildcards
+ */
+function convertRouteToPattern(route) {
+  if (!route || route === '/') return '/';
+
+  const segments = route.split('/').filter(Boolean);
+  const patternSegments = segments.map(segment => {
+    // Rest parameter: [...params] -> **
+    if (segment.startsWith('[...') && segment.endsWith(']')) {
+      return '**';
+    }
+
+    // Required or optional parameter: [param] or [[param]] -> *
+    if ((segment.startsWith('[') && segment.endsWith(']')) ||
+        (segment.startsWith('[[') && segment.endsWith(']]'))) {
+      return '*';
+    }
+
+    // Static segment: keep as-is
+    return segment;
+  });
+
+  return '/' + patternSegments.join('/');
 }
 
 /** @param {string} str */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openworkers/adapter-sveltekit",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "SvelteKit adapter for OpenWorkers",
   "keywords": [
     "adapter",