@openworkers/adapter-sveltekit 0.2.2 → 0.3.0

package/README.md

@@ -17,19 +17,77 @@ import adapter from '@openworkers/adapter-sveltekit';
 export default {
   kit: {
     adapter: adapter({
-      out: 'dist' // default
+      out: 'dist',      // Output directory (default: 'dist')
+      functions: false  // Generate mini-workers for API routes (default: false)
     })
   }
 };
 ```
 
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `out` | `string` | `'dist'` | Output directory for the build |
+| `functions` | `boolean` | `false` | Generate separate mini-workers for each API route |
+
 ## Output
 
 ```
 dist/
-  worker.js    # Worker entry point
-  routes.js    # Route manifest for edge routing
-  assets/      # Static assets and prerendered pages
+├── 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)
+    ├── api-hello.js
+    └── api-users.js
+```
+
+## Functions Mode
+
+When `functions: true`, the adapter generates a separate mini-worker for each `+server.ts` endpoint:
+
+- `/api/hello/+server.ts` → `functions/api-hello.js`
+- `/api/users/+server.ts` → `functions/api-users.js`
+
+The route mappings are included in `routes.js`:
+
+```js
+{
+  "functions": [
+    { "pattern": "/api/hello", "worker": "functions/api-hello.js" },
+    { "pattern": "/api/users", "worker": "functions/api-users.js" }
+  ]
+}
+```
+
+This prepares for native project routing in the OpenWorkers runner, where each function can be deployed as a separate worker for better isolation and scaling.
+
+## TypeScript
+
+For proper types on `platform.env`, add `@openworkers/workers-types`:
+
+```bash
+bun add -d @openworkers/workers-types
+```
+
+Then in `src/app.d.ts`:
+
+```ts
+/// <reference types="@openworkers/workers-types" />
+
+declare global {
+  namespace App {
+    interface Platform {
+      env: {
+        KV: BindingKV;
+        ASSETS: BindingAssets;
+      };
+    }
+  }
+}
+
+export {};
 ```
 
 ## License

package/files/function-worker.js

@@ -0,0 +1,46 @@
+/**
+ * Mini-worker template for OpenWorkers Functions.
+ * Wraps a SvelteKit API endpoint as a standalone worker.
+ */
+
+import * as handlers from 'ENDPOINT';
+
+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' }
+			});
+		}
+	}
+};

package/files/shims/async_hooks.js

@@ -0,0 +1,41 @@
+/**
+ * Minimal AsyncLocalStorage shim for OpenWorkers.
+ *
+ * OpenWorkers creates a fresh V8 context per request.
+ * Module-level state is already isolated, so no real async tracking is needed.
+ */
+
+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);
+	}
+}

package/index.d.ts

@@ -6,6 +6,13 @@ export interface AdapterOptions {
    * @default 'dist'
    */
   out?: string;
+
+  /**
+   * Generate separate mini-workers for each API route.
+   * Outputs to `dist/functions/` with routing info in `routes.js`.
+   * @default false
+   */
+  functions?: boolean;
 }
 
 export default function plugin(options?: AdapterOptions): Adapter;

package/index.js

@@ -1,4 +1,4 @@
-import { existsSync, writeFileSync } from 'node:fs';
+import { existsSync, writeFileSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { build } from 'esbuild';
@@ -13,6 +13,7 @@ export default function (options = {}) {
     async adapt(builder) {
       const dest = options.out ?? 'dist';
       const assetsDir = `${dest}/assets`;
+      const functionsEnabled = options.functions ?? false;
 
       const files = fileURLToPath(new URL('./files', import.meta.url).href);
       const tmp = builder.getBuildDirectory('openworkers-tmp');
@@ -34,6 +35,7 @@ export default function (options = {}) {
 
       // Generate 404.html fallback
       const fallback = path.join(assetsDir, '404.html');
+
       if (!existsSync(fallback)) {
         writeFileSync(fallback, 'Not Found');
       }
@@ -58,8 +60,9 @@ export default function (options = {}) {
           `export { Server, manifest, prerendered, base_path };\n`
       );
 
-      // Bundle worker with esbuild
+      // Bundle main worker with esbuild
       const workerDest = `${dest}/worker.js`;
+      const shimAsyncHooks = posixify(path.resolve(files, 'shims/async_hooks.js'));
 
       await build({
         entryPoints: [`${files}/worker.js`],
@@ -69,7 +72,8 @@ export default function (options = {}) {
         outfile: workerDest,
         alias: {
           SERVER: entryPoint,
-          MANIFEST: entryPoint
+          MANIFEST: entryPoint,
+          'node:async_hooks': shimAsyncHooks
         },
         external: ['node:*'],
         minify: false,
@@ -78,6 +82,91 @@ export default function (options = {}) {
         }
       });
 
+      // Generate mini-workers for API routes if enabled
+      /** @type {Array<{pattern: string, worker: string}>} */
+      const functions = [];
+
+      if (functionsEnabled) {
+        builder.mkdirp(`${dest}/functions`);
+
+        const endpointsDir = path.join(builder.getServerDirectory(), 'entries/endpoints');
+
+        if (existsSync(endpointsDir)) {
+          const endpoints = findEndpoints(endpointsDir);
+
+          for (const endpoint of endpoints) {
+            const routePattern = endpoint.route;
+            const workerName = routePattern.replace(/\//g, '-').replace(/^-/, '') || 'index';
+            const workerFile = `functions/${workerName}.js`;
+
+            // Create entry point for this function
+            const functionEntry = `${tmp}/function-${workerName}.js`;
+            const endpointPath = posixify(endpoint.file);
+
+            writeFileSync(
+              functionEntry,
+              `import * as handlers from '${endpointPath}';\n` +
+                `export default {\n` +
+                `  async fetch(req, env, ctx) {\n` +
+                `    globalThis.env = env;\n` +
+                `    const method = req.method;\n` +
+                `    const handler = handlers[method];\n` +
+                `    if (!handler) {\n` +
+                `      return new Response('Method Not Allowed', {\n` +
+                `        status: 405,\n` +
+                `        headers: { Allow: Object.keys(handlers).join(', ') }\n` +
+                `      });\n` +
+                `    }\n` +
+                `    const url = new URL(req.url);\n` +
+                `    const event = {\n` +
+                `      request: req,\n` +
+                `      url,\n` +
+                `      params: ctx.params ?? {},\n` +
+                `      platform: { env, ctx },\n` +
+                `      getClientAddress() {\n` +
+                `        return req.headers.get('x-real-ip') ?? req.headers.get('x-forwarded-for') ?? '';\n` +
+                `      }\n` +
+                `    };\n` +
+                `    try {\n` +
+                `      return await handler(event);\n` +
+                `    } catch (error) {\n` +
+                `      console.error('[Function] Error:', error);\n` +
+                `      return new Response(JSON.stringify({ error: 'Internal Server Error' }), {\n` +
+                `        status: 500,\n` +
+                `        headers: { 'Content-Type': 'application/json' }\n` +
+                `      });\n` +
+                `    }\n` +
+                `  }\n` +
+                `};\n`
+            );
+
+            // Bundle the function
+            await build({
+              entryPoints: [functionEntry],
+              bundle: true,
+              format: 'esm',
+              platform: 'browser',
+              outfile: `${dest}/${workerFile}`,
+              alias: {
+                'node:async_hooks': shimAsyncHooks
+              },
+              external: ['node:*'],
+              minify: false,
+              banner: {
+                js: `// Generated by ${name} - Function: ${routePattern}\n`
+              }
+            });
+
+            functions.push({
+              pattern: routePattern,
+              worker: workerFile
+            });
+
+            builder.log.minor(`  Generated function: ${routePattern} → ${workerFile}`);
+          }
+        }
+      }
+
       // Generate routes.js for edge routing
       const routes = {
         // Immutable assets (hashed filenames, cache forever)
@@ -86,6 +175,8 @@ export default function (options = {}) {
         static: staticFiles.map((f) => `/${f}`),
         // Prerendered pages (serve from assets, no worker needed)
         prerendered: builder.prerendered.paths,
+        // Functions (API routes as separate workers)
+        functions: functions,
         // Everything else -> SSR
         ssr: ['/*']
       };
@@ -99,11 +190,43 @@ export default function (options = {}) {
 
       builder.log.minor(`Wrote ${workerDest}`);
       builder.log.minor(`Wrote ${dest}/routes.js`);
+
+      if (functions.length > 0) {
+        builder.log.minor(`Wrote ${functions.length} function workers to ${dest}/functions/`);
+      }
+
       builder.log.minor(`Wrote ${assetsDir} (${builder.prerendered.paths.length} prerendered pages)`);
     }
   };
 }
 
+/**
+ * Find all endpoint files in the server output
+ * @param {string} dir
+ * @param {string} [base='']
+ * @returns {Array<{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
+      });
+    }
+  }
+
+  return results;
+}
+
 /** @param {string} str */
 function posixify(str) {
   return str.replace(/\\/g, '/');

package/package.json

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