@cloudwerk/vite-plugin 0.5.0 → 0.6.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from 'vite';
-import { CloudwerkConfig, RouteManifest, ScanResult } from '@cloudwerk/core/build';
+import { CloudwerkConfig, RouteManifest, ScanResult, QueueManifest, ServiceManifest } from '@cloudwerk/core/build';
 
 /**
  * @cloudwerk/vite-plugin - Types
@@ -150,6 +150,15 @@ declare function cloudwerkPlugin(options?: CloudwerkVitePluginOptions): Plugin;
  * a Hono app with all routes registered from the file-based routing manifest.
  */
 
+/**
+ * Options for generating server entry.
+ */
+interface GenerateServerEntryOptions {
+    /** Queue manifest if queues are configured */
+    queueManifest?: QueueManifest | null;
+    /** Service manifest if services are configured */
+    serviceManifest?: ServiceManifest | null;
+}
 /**
  * Generate the server entry module code.
  *
@@ -165,7 +174,7 @@ declare function cloudwerkPlugin(options?: CloudwerkVitePluginOptions): Plugin;
  * @param options - Resolved plugin options
  * @returns Generated TypeScript/JavaScript code
  */
-declare function generateServerEntry(manifest: RouteManifest, scanResult: ScanResult, options: ResolvedCloudwerkOptions): string;
+declare function generateServerEntry(manifest: RouteManifest, scanResult: ScanResult, options: ResolvedCloudwerkOptions, entryOptions?: GenerateServerEntryOptions): string;
 
 /**
  * Client Entry Virtual Module Generator

package/dist/index.js

@@ -12,7 +12,14 @@ import {
   resolveRoutesPath,
   hasUseClientDirective,
   generateComponentId,
-  ROUTE_FILE_NAMES
+  ROUTE_FILE_NAMES,
+  scanQueues,
+  buildQueueManifest,
+  QUEUES_DIR,
+  scanServices,
+  buildServiceManifest,
+  SERVICES_DIR,
+  SERVICE_FILE_NAME
 } from "@cloudwerk/core/build";
 
 // src/types.ts
@@ -29,7 +36,9 @@ var RESOLVED_VIRTUAL_IDS = {
 
 // src/virtual-modules/server-entry.ts
 import * as path from "path";
-function generateServerEntry(manifest, scanResult, options) {
+function generateServerEntry(manifest, scanResult, options, entryOptions) {
+  const queueManifest = entryOptions?.queueManifest;
+  const serviceManifest = entryOptions?.serviceManifest;
   const imports = [];
   const pageRegistrations = [];
   const routeRegistrations = [];
@@ -48,6 +57,7 @@ function generateServerEntry(manifest, scanResult, options) {
   let middlewareIndex = 0;
   let errorIndex = 0;
   let notFoundIndex = 0;
+  const ssgPageInfo = [];
   for (const err of scanResult.errors) {
     if (!importedModules.has(err.absolutePath)) {
       const varName = `error_${errorIndex++}`;
@@ -100,6 +110,10 @@ function generateServerEntry(manifest, scanResult, options) {
     if (route.fileType === "page") {
       const varName = `page_${pageIndex++}`;
       imports.push(`import * as ${varName} from '${route.absolutePath}'`);
+      const hasDynamicSegments = route.segments.some(
+        (s) => s.type === "dynamic" || s.type === "catchAll" || s.type === "optionalCatchAll"
+      );
+      ssgPageInfo.push({ varName, urlPattern: route.urlPattern, hasDynamicSegments });
       const layoutChain = route.layouts.map((p) => layoutModules.get(p)).join(", ");
       const middlewareChain = route.middleware.map((p) => middlewareModules.get(p)).join(", ");
       const errorModule = route.errorBoundary ? errorModules.get(route.errorBoundary) : null;
@@ -131,6 +145,7 @@ function generateServerEntry(manifest, scanResult, options) {
  */
 
 import { Hono } from 'hono'
+import { ssgParams } from 'hono/ssg'
 import { contextMiddleware, createHandlerAdapter, createMiddlewareAdapter, setRouteConfig, NotFoundError, RedirectError } from '@cloudwerk/core/runtime'
 import { setActiveRenderer } from '@cloudwerk/ui'
 
@@ -301,6 +316,11 @@ function registerPage(app, pattern, pageModule, layoutModules, middlewareModules
     })
   }
 
+  // Apply SSG params middleware if page has generateStaticParams (for static generation)
+  if (typeof pageModule.generateStaticParams === 'function') {
+    app.use(pattern, ssgParams(pageModule.generateStaticParams))
+  }
+
   // Register GET handler for page
   app.get(pattern, async (c) => {
     const params = c.req.param()
@@ -465,6 +485,13 @@ app.use('*', async (c, next) => {
 ${pageRegistrations.join("\n")}
 ${routeRegistrations.join("\n")}
 
+// SSG routes endpoint - returns all static routes for build-time generation
+app.get('/__ssg/routes', async (c) => {
+  const routes = []
+${generateSSGRouteChecks(ssgPageInfo)}
+  return c.json({ routes })
+})
+
 // 404 handler
 app.notFound(async (c) => {
   const path = c.req.path
@@ -532,8 +559,167 @@ app.onError(async (err, c) => {
 // ============================================================================
 
 export default app
+${generateQueueExports(queueManifest)}
+${generateServiceRegistration(serviceManifest)}
 `;
 }
+function generateSSGRouteChecks(pages) {
+  const lines = [];
+  for (const page of pages) {
+    if (page.hasDynamicSegments) {
+      lines.push(`  // ${page.urlPattern}`);
+      lines.push(`  if (typeof ${page.varName}.generateStaticParams === 'function') {`);
+      lines.push(`    try {`);
+      lines.push(`      const params = await ${page.varName}.generateStaticParams()`);
+      lines.push(`      if (Array.isArray(params)) {`);
+      lines.push(`        for (const p of params) {`);
+      lines.push(`          let url = '${page.urlPattern}'`);
+      lines.push(`          for (const [key, value] of Object.entries(p)) {`);
+      lines.push(`            url = url.replace(':' + key, String(value))`);
+      lines.push(`          }`);
+      lines.push(`          routes.push(url)`);
+      lines.push(`        }`);
+      lines.push(`      }`);
+      lines.push(`    } catch (e) {`);
+      lines.push(`      console.error('SSG: Failed to get params for ${page.urlPattern}:', e)`);
+      lines.push(`    }`);
+      lines.push(`  }`);
+    } else {
+      lines.push(`  // ${page.urlPattern}`);
+      lines.push(`  if ('config' in ${page.varName} && ${page.varName}.config?.rendering === 'static') {`);
+      lines.push(`    routes.push('${page.urlPattern}')`);
+      lines.push(`  }`);
+    }
+  }
+  return lines.join("\n");
+}
+function generateQueueExports(queueManifest) {
+  if (!queueManifest || queueManifest.queues.length === 0) {
+    return "";
+  }
+  const lines = [];
+  const imports = [];
+  const queueHandlers = [];
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Queue Consumer Handlers");
+  lines.push("// ============================================================================");
+  lines.push("");
+  for (let i = 0; i < queueManifest.queues.length; i++) {
+    const queue = queueManifest.queues[i];
+    const varName = `queueDef_${i}`;
+    imports.push(`import ${varName} from '${queue.absolutePath}'`);
+    queueHandlers.push(`
+/**
+ * Queue consumer handler for '${queue.name}'
+ */
+async function handle_${queue.name}_queue(batch, env, ctx) {
+  const definition = ${varName}
+
+  // Create message wrappers
+  const messages = batch.messages.map((msg) => ({
+    id: msg.id,
+    body: msg.body,
+    timestamp: new Date(msg.timestamp),
+    attempts: msg.attempts,
+    ack: () => msg.ack(),
+    retry: (options) => msg.retry(options),
+    deadLetter: (reason) => {
+      // Mark for DLQ if configured
+      if (definition.config?.deadLetterQueue) {
+        msg.retry({ delaySeconds: 0 })
+      }
+    },
+  }))
+
+  // Validate messages if schema is defined
+  if (definition.schema) {
+    for (const message of messages) {
+      const result = definition.schema.safeParse(message.body)
+      if (!result.success) {
+        console.error('Queue message validation failed:', result.error)
+        message.retry({ delaySeconds: 60 })
+        return
+      }
+    }
+  }
+
+  try {
+    // Use batch processor if available
+    if (definition.processBatch) {
+      await definition.processBatch(messages)
+    } else if (definition.process) {
+      // Process messages individually
+      for (const message of messages) {
+        try {
+          await definition.process(message)
+        } catch (error) {
+          if (definition.onError) {
+            await definition.onError(error, message)
+          } else {
+            throw error
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Queue processing error:', error)
+    // Retry all messages
+    batch.retryAll()
+  }
+}`);
+  }
+  lines.push(imports.join("\n"));
+  lines.push(queueHandlers.join("\n"));
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * Main queue handler that routes to specific queue handlers.");
+  lines.push(" * Export this as the `queue` handler in your worker.");
+  lines.push(" */");
+  lines.push("export async function queue(batch, env, ctx) {");
+  lines.push("  const queueName = batch.queue");
+  lines.push("");
+  for (const queue of queueManifest.queues) {
+    lines.push(`  if (queueName === '${queue.queueName}') {`);
+    lines.push(`    return handle_${queue.name}_queue(batch, env, ctx)`);
+    lines.push("  }");
+    lines.push("");
+  }
+  lines.push("  console.warn(\\`Unknown queue: \\${queueName}\\`)");
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateServiceRegistration(serviceManifest) {
+  if (!serviceManifest || serviceManifest.services.length === 0) {
+    return "";
+  }
+  const lines = [];
+  const imports = [];
+  const registrations = [];
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Service Registration");
+  lines.push("// ============================================================================");
+  lines.push("");
+  imports.push("import { registerLocalService } from '@cloudwerk/core/bindings'");
+  for (let i = 0; i < serviceManifest.services.length; i++) {
+    const service = serviceManifest.services[i];
+    const varName = `serviceDef_${i}`;
+    imports.push(`import ${varName} from '${service.absolutePath}'`);
+    if (service.mode === "local") {
+      registrations.push(`registerLocalService('${service.name}', ${varName})`);
+    }
+  }
+  lines.push(imports.join("\n"));
+  lines.push("");
+  if (registrations.length > 0) {
+    lines.push("// Register local services");
+    for (const reg of registrations) {
+      lines.push(reg);
+    }
+  }
+  return lines.join("\n");
+}
 
 // src/virtual-modules/client-entry.ts
 function generateClientEntry(clientComponents, options) {
@@ -1437,6 +1623,55 @@ function cloudwerkPlugin(options = {}) {
       console.log(`[cloudwerk] Found ${state.manifest.routes.length} routes`);
     }
   }
+  async function buildQueueManifestIfExists(root) {
+    if (!state) {
+      throw new Error("Plugin state not initialized");
+    }
+    const queuesPath = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+    try {
+      await fs2.promises.access(queuesPath);
+    } catch {
+      state.queueScanResult = null;
+      state.queueManifest = null;
+      return;
+    }
+    state.queueScanResult = await scanQueues(
+      path3.resolve(root, state.options.appDir),
+      { extensions: state.options.config.extensions }
+    );
+    state.queueManifest = buildQueueManifest(
+      state.queueScanResult,
+      root,
+      { appName: "cloudwerk" }
+    );
+    if (state.options.verbose && state.queueManifest.queues.length > 0) {
+      console.log(`[cloudwerk] Found ${state.queueManifest.queues.length} queue(s)`);
+    }
+  }
+  async function buildServiceManifestIfExists(root) {
+    if (!state) {
+      throw new Error("Plugin state not initialized");
+    }
+    const servicesPath = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+    try {
+      await fs2.promises.access(servicesPath);
+    } catch {
+      state.serviceScanResult = null;
+      state.serviceManifest = null;
+      return;
+    }
+    state.serviceScanResult = await scanServices(
+      path3.resolve(root, state.options.appDir),
+      { extensions: state.options.config.extensions }
+    );
+    state.serviceManifest = buildServiceManifest(
+      state.serviceScanResult,
+      root
+    );
+    if (state.options.verbose && state.serviceManifest.services.length > 0) {
+      console.log(`[cloudwerk] Found ${state.serviceManifest.services.length} service(s)`);
+    }
+  }
   function isRouteFile(filePath) {
     if (!state) return false;
     const appDir = path3.resolve(state.options.root, state.options.appDir);
@@ -1445,6 +1680,25 @@ function cloudwerkPlugin(options = {}) {
     const nameWithoutExt = basename2.replace(/\.(ts|tsx|js|jsx)$/, "");
     return ROUTE_FILE_NAMES.includes(nameWithoutExt);
   }
+  function isQueueFile(filePath) {
+    if (!state) return false;
+    const queuesDir = path3.resolve(state.options.root, state.options.appDir, QUEUES_DIR);
+    if (!filePath.startsWith(queuesDir)) return false;
+    const relativePath = path3.relative(queuesDir, filePath);
+    if (relativePath.includes(path3.sep)) return false;
+    const ext = path3.extname(filePath);
+    return state.options.config.extensions.includes(ext);
+  }
+  function isServiceFile(filePath) {
+    if (!state) return false;
+    const servicesDir = path3.resolve(state.options.root, state.options.appDir, SERVICES_DIR);
+    if (!filePath.startsWith(servicesDir)) return false;
+    const basename2 = path3.basename(filePath);
+    const ext = path3.extname(filePath);
+    const nameWithoutExt = basename2.replace(ext, "");
+    if (nameWithoutExt !== SERVICE_FILE_NAME) return false;
+    return state.options.config.extensions.includes(ext);
+  }
   function invalidateVirtualModules() {
     if (!server) return;
     const idsToInvalidate = [
@@ -1535,11 +1789,17 @@ function cloudwerkPlugin(options = {}) {
           errors: [],
           notFound: []
         },
+        queueManifest: null,
+        queueScanResult: null,
+        serviceManifest: null,
+        serviceScanResult: null,
         clientComponents: /* @__PURE__ */ new Map(),
         serverEntryCache: null,
         clientEntryCache: null
       };
       await buildManifest(root);
+      await buildQueueManifestIfExists(root);
+      await buildServiceManifestIfExists(root);
       await scanClientComponents(root, state);
     },
     /**
@@ -1559,6 +1819,22 @@ function cloudwerkPlugin(options = {}) {
           await buildManifest(state.options.root);
           invalidateVirtualModules();
         }
+        if (isQueueFile(filePath)) {
+          const queuesDir = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Queue added: ${path3.relative(queuesDir, filePath)}`);
+          }
+          await buildQueueManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
+        if (isServiceFile(filePath)) {
+          const servicesDir = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Service added: ${path3.relative(servicesDir, filePath)}`);
+          }
+          await buildServiceManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
       });
       devServer.watcher.on("unlink", async (filePath) => {
         if (isRouteFile(filePath)) {
@@ -1568,6 +1844,22 @@ function cloudwerkPlugin(options = {}) {
           await buildManifest(state.options.root);
           invalidateVirtualModules();
         }
+        if (isQueueFile(filePath)) {
+          const queuesDir = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Queue removed: ${path3.relative(queuesDir, filePath)}`);
+          }
+          await buildQueueManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
+        if (isServiceFile(filePath)) {
+          const servicesDir = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Service removed: ${path3.relative(servicesDir, filePath)}`);
+          }
+          await buildServiceManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
       });
       devServer.watcher.on("change", async (filePath) => {
         if (isRouteFile(filePath)) {
@@ -1577,6 +1869,22 @@ function cloudwerkPlugin(options = {}) {
           await buildManifest(state.options.root);
           invalidateVirtualModules();
         }
+        if (isQueueFile(filePath)) {
+          const queuesDir = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Queue changed: ${path3.relative(queuesDir, filePath)}`);
+          }
+          await buildQueueManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
+        if (isServiceFile(filePath)) {
+          const servicesDir = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Service changed: ${path3.relative(servicesDir, filePath)}`);
+          }
+          await buildServiceManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
         const wranglerPath2 = findWranglerTomlPath(root);
         if (wranglerPath2 && filePath === wranglerPath2) {
           if (verbose) {
@@ -1621,7 +1929,11 @@ function cloudwerkPlugin(options = {}) {
           state.serverEntryCache = generateServerEntry(
             state.manifest,
             state.scanResult,
-            state.options
+            state.options,
+            {
+              queueManifest: state.queueManifest,
+              serviceManifest: state.serviceManifest
+            }
           );
         }
         return state.serverEntryCache;
@@ -1655,13 +1967,71 @@ function cloudwerkPlugin(options = {}) {
       return null;
     },
     /**
-     * Transform hook to detect and wrap client components.
+     * Transform hook to detect and wrap client components,
+     * and rewrite binding imports to use the bindings proxy.
      */
     transform(code, id) {
       if (!state) return null;
       if (id.includes("node_modules")) return null;
       if (!id.endsWith(".tsx") && !id.endsWith(".ts")) return null;
-      if (hasUseClientDirective(code)) {
+      let transformedCode = code;
+      let wasTransformed = false;
+      const bindingsImportRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@cloudwerk\/core\/bindings['"]/g;
+      if (bindingsImportRegex.test(code)) {
+        bindingsImportRegex.lastIndex = 0;
+        transformedCode = code.replace(bindingsImportRegex, (match, imports) => {
+          const importNames = imports.split(",").map((s) => s.trim()).filter(Boolean);
+          const knownExports = [
+            "bindings",
+            "getBinding",
+            "hasBinding",
+            "getBindingNames",
+            "queues",
+            "getQueue",
+            "hasQueue",
+            "getQueueNames",
+            "services",
+            "getService",
+            "hasService",
+            "getServiceNames",
+            "registerLocalService",
+            "unregisterLocalService",
+            "clearLocalServices",
+            "durableObjects",
+            "getDurableObject",
+            "hasDurableObject",
+            "getDurableObjectNames",
+            "createLazyBinding"
+          ];
+          const runtimeImports = [];
+          const bindingImports = [];
+          for (const name of importNames) {
+            const [originalName] = name.split(/\s+as\s+/);
+            if (knownExports.includes(originalName.trim())) {
+              runtimeImports.push(name);
+            } else {
+              bindingImports.push(name);
+            }
+          }
+          if (bindingImports.length === 0) {
+            return match;
+          }
+          wasTransformed = true;
+          const parts = [];
+          const helperImports = runtimeImports.includes("createLazyBinding") ? runtimeImports : ["createLazyBinding", ...runtimeImports];
+          parts.push(`import { ${helperImports.join(", ")} } from '@cloudwerk/core/bindings'`);
+          for (const name of bindingImports) {
+            const aliasMatch = name.match(/^(\w+)\s+as\s+(\w+)$/);
+            if (aliasMatch) {
+              parts.push(`const ${aliasMatch[2]} = createLazyBinding('${aliasMatch[1]}')`);
+            } else {
+              parts.push(`const ${name.trim()} = createLazyBinding('${name.trim()}')`);
+            }
+          }
+          return parts.join("\n");
+        });
+      }
+      if (hasUseClientDirective(transformedCode)) {
         const componentId = generateComponentId(id, state.options.root);
         const bundlePath = `${state.options.hydrationEndpoint}/${componentId}.js`;
         const info = {
@@ -1674,7 +2044,7 @@ function cloudwerkPlugin(options = {}) {
         if (state.options.verbose) {
           console.log(`[cloudwerk] Detected client component: ${componentId}`);
         }
-        const result = transformClientComponent(code, {
+        const result = transformClientComponent(transformedCode, {
           componentId,
           bundlePath: id
           // Use file path for Vite to resolve in dev mode
@@ -1687,6 +2057,12 @@ function cloudwerkPlugin(options = {}) {
           map: null
         };
       }
+      if (wasTransformed) {
+        return {
+          code: transformedCode,
+          map: null
+        };
+      }
       return null;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/vite-plugin",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Vite plugin for Cloudwerk file-based routing with virtual entry generation",
   "repository": {
     "type": "git",
@@ -19,8 +19,8 @@
   ],
   "dependencies": {
     "@swc/core": "^1.3.100",
-    "@cloudwerk/core": "^0.12.0",
-    "@cloudwerk/ui": "^0.12.0"
+    "@cloudwerk/core": "^0.14.0",
+    "@cloudwerk/ui": "^0.14.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0",