@oselvar/sveltekit-add-worker-exports 0.1.3 → 0.3.0

package/README.md

@@ -4,7 +4,7 @@ A Vite plugin that makes Durable Objects and Workflows work with SvelteKit on Cl
 
 **Build mode:** SvelteKit's `adapter-cloudflare` generates `_worker.js` with only a default export (the fetch handler). Cloudflare Workers requires Durable Object and Workflow classes to be **named exports**. This plugin post-processes the build output to merge your named exports with SvelteKit's default export.
 
-**Dev mode:** `getPlatformProxy` (used by `adapter-cloudflare` in dev) can't run internal Durable Objects. This plugin starts a separate wrangler dev server that runs the real DO worker with hot-reload. Clients connect directly to it via WebSocket on a separate port.
+**Dev mode:** `getPlatformProxy` (used by `adapter-cloudflare` in dev) can't run internal Durable Objects or Workflows. This plugin starts a separate wrangler dev server that runs the real DO/Workflow worker with hot-reload. SvelteKit `+server.ts` handlers call DOs through `platform.env.MY_DO.<rpc>()` as usual — the plugin rewrites those bindings to point at the sidecar via wrangler's dev registry, so cross-worker calls Just Work. Clients can also connect directly to the sidecar via WebSocket on a separate port (see below).
 
 ## Install
 
@@ -21,9 +21,12 @@ Create a worker entry point that exports your Durable Object classes and a defau
 ```typescript
 // src/lib/server/index.ts
 export { MyDurableObject } from './MyDurableObject';
+export { MyWorkflow } from './MyWorkflow';
 export { default } from './devHandler';
 ```
 
+Workflow classes (extending `WorkflowEntrypoint`) are exported the same way as Durable Objects — the plugin merges them into `_worker.js` as named exports. Declare them in `wrangler.jsonc` under `workflows`, and they become available as bindings (e.g. `env.MY_WORKFLOW.create({ params })`) in both dev and production.
+
 Both the dev handler and the production SvelteKit route need to do the same thing: validate the upgrade header and forward the request to a Durable Object. Extract that into a small helper so the two callers stay in sync:
 
 ```typescript
@@ -84,6 +87,23 @@ export default defineConfig({
 });
 ```
 
+Point `adapter-cloudflare`'s platform proxy at the generated `.platform-proxy-wrangler.jsonc`. The plugin writes this file with internal Durable Object bindings rewritten to cross-worker form (each gets a `script_name` pointing at the sidecar). Workflows and migrations are stripped — calling a Workflow from `platform.env` in vite dev isn't supported, but it works in production. Without this config path, `getPlatformProxy` would try to run the classes itself and warn that it can't:
+
+```javascript
+// svelte.config.js
+import adapter from '@sveltejs/adapter-cloudflare';
+
+export default {
+  kit: {
+    adapter: adapter({
+      platformProxy: {
+        configPath: '.platform-proxy-wrangler.jsonc'
+      }
+    })
+  }
+};
+```
+
 ### Dev mode: connecting to Durable Objects
 
 In dev mode, the plugin starts a wrangler dev server on a separate port and injects `__DEV_WORKER_PORT__` as a compile-time constant. Use it to connect your client:

package/dist/index.js

@@ -17,10 +17,31 @@
  * @see https://github.com/sveltejs/kit/issues/1712
  */
 import { build } from 'esbuild';
+import { existsSync } from 'node:fs';
 import { access, readFile, rename, writeFile, unlink } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
 const DEFAULT_DEV_PORT = 8787;
+/**
+ * Mirrors wrangler's internal getRegistryPath() — wrangler doesn't export it.
+ * Workers register themselves under this path so cross-worker `script_name`
+ * bindings can find each other.
+ */
+function getWranglerRegistryPath() {
+    if (process.env.WRANGLER_REGISTRY_PATH)
+        return process.env.WRANGLER_REGISTRY_PATH;
+    const legacy = join(homedir(), '.wrangler');
+    if (existsSync(legacy))
+        return join(legacy, 'registry');
+    if (process.platform === 'darwin') {
+        return join(homedir(), 'Library', 'Preferences', '.wrangler', 'registry');
+    }
+    if (process.platform === 'win32') {
+        return join(process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming'), '.wrangler', 'registry');
+    }
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), '.wrangler', 'registry');
+}
 /**
  * Returns two Vite plugins: one for build (patches _worker.js) and one for
  * dev (starts a wrangler dev server for Durable Objects).
@@ -76,6 +97,7 @@ function devPlugin(options) {
     const devPort = options.devPort ?? DEFAULT_DEV_PORT;
     let worker = null;
     let tempConfigPath = null;
+    let proxyConfigPath = null;
     return {
         name: 'add-worker-exports-dev',
         apply: 'serve',
@@ -99,7 +121,25 @@ function devPlugin(options) {
             delete devConfig.assets;
             tempConfigPath = resolve('.dev-worker-wrangler.jsonc');
             await writeFile(tempConfigPath, JSON.stringify(devConfig, null, '\t'));
-            worker = await unstable_startWorker({ config: tempConfigPath });
+            // Also write a wrangler config for adapter-cloudflare's getPlatformProxy
+            // (used by vite dev for platform.env). It can't run internal DOs or
+            // Workflows itself -- those are served by the sidecar above. Rewrite
+            // internal DO bindings as cross-worker bindings (script_name pointing
+            // at the sidecar) so platform.env.MY_DO calls in +server.ts reach the
+            // sidecar via the wrangler dev registry. Workflows and migrations get
+            // stripped (Workflow bindings have no script_name equivalent).
+            const proxyConfig = parseJsonc(rawJson);
+            if (proxyConfig.durable_objects?.bindings) {
+                proxyConfig.durable_objects.bindings = proxyConfig.durable_objects.bindings.map((b) => b.script_name ? b : { ...b, script_name: devConfig.name });
+            }
+            delete proxyConfig.workflows;
+            delete proxyConfig.migrations;
+            proxyConfigPath = resolve('.platform-proxy-wrangler.jsonc');
+            await writeFile(proxyConfigPath, JSON.stringify(proxyConfig, null, '\t'));
+            worker = await unstable_startWorker({
+                config: tempConfigPath,
+                dev: { registry: getWranglerRegistryPath() }
+            });
             server.httpServer?.on('close', async () => {
                 if (worker) {
                     await worker.dispose();
@@ -108,6 +148,9 @@ function devPlugin(options) {
                 if (tempConfigPath) {
                     await unlink(tempConfigPath).catch(() => { });
                 }
+                if (proxyConfigPath) {
+                    await unlink(proxyConfigPath).catch(() => { });
+                }
             });
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oselvar/sveltekit-add-worker-exports",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Vite plugin that adds Durable Object and Workflow exports to SvelteKit Cloudflare workers",
   "type": "module",
   "publishConfig": {