@cloudwerk/vite-plugin 0.5.0 → 0.6.0

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 = [];
@@ -532,8 +541,137 @@ app.onError(async (err, c) => {
 // ============================================================================
 
 export default app
+${generateQueueExports(queueManifest)}
+${generateServiceRegistration(serviceManifest)}
 `;
 }
+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 +1575,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 +1632,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 +1741,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 +1771,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 +1796,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 +1821,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 +1881,11 @@ function cloudwerkPlugin(options = {}) {
           state.serverEntryCache = generateServerEntry(
             state.manifest,
             state.scanResult,
-            state.options
+            state.options,
+            {
+              queueManifest: state.queueManifest,
+              serviceManifest: state.serviceManifest
+            }
           );
         }
         return state.serverEntryCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/vite-plugin",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "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.13.0",
+    "@cloudwerk/ui": "^0.13.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0",