@cloudwerk/vite-plugin 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/plugin.ts
-import * as path2 from "path";
-import * as fs from "fs";
+import * as path3 from "path";
+import * as fs2 from "fs";
 import {
   scanRoutes,
   buildRouteManifest,
@@ -1037,25 +1037,358 @@ export default __WrappedComponent
   }
 }
 
+// src/wrangler-watcher.ts
+import * as fs from "fs";
+import * as path2 from "path";
+var TYPE_MAPPINGS = {
+  d1: "D1Database",
+  kv: "KVNamespace",
+  r2: "R2Bucket",
+  queue: "Queue",
+  do: "DurableObjectNamespace",
+  service: "Fetcher",
+  secret: "string",
+  ai: "Ai",
+  vectorize: "VectorizeIndex",
+  hyperdrive: "Hyperdrive"
+};
+function parseSimpleToml(content) {
+  const result = {};
+  const d1Matches = content.matchAll(/\[\[d1_databases\]\]\s*\n([^[]*)/g);
+  for (const match of d1Matches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.d1_databases) result.d1_databases = [];
+      result.d1_databases.push({ binding: bindingMatch[1] });
+    }
+  }
+  const kvMatches = content.matchAll(/\[\[kv_namespaces\]\]\s*\n([^[]*)/g);
+  for (const match of kvMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.kv_namespaces) result.kv_namespaces = [];
+      result.kv_namespaces.push({ binding: bindingMatch[1] });
+    }
+  }
+  const r2Matches = content.matchAll(/\[\[r2_buckets\]\]\s*\n([^[]*)/g);
+  for (const match of r2Matches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.r2_buckets) result.r2_buckets = [];
+      result.r2_buckets.push({ binding: bindingMatch[1] });
+    }
+  }
+  const queueMatches = content.matchAll(/\[\[queues\.producers\]\]\s*\n([^[]*)/g);
+  for (const match of queueMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.queues) result.queues = {};
+      if (!result.queues.producers) result.queues.producers = [];
+      result.queues.producers.push({ binding: bindingMatch[1] });
+    }
+  }
+  const doMatches = content.matchAll(/\[\[durable_objects\.bindings\]\]\s*\n([^[]*)/g);
+  for (const match of doMatches) {
+    const nameMatch = match[1].match(/name\s*=\s*["']([^"']+)["']/);
+    if (nameMatch) {
+      if (!result.durable_objects) result.durable_objects = {};
+      if (!result.durable_objects.bindings) result.durable_objects.bindings = [];
+      result.durable_objects.bindings.push({ name: nameMatch[1] });
+    }
+  }
+  const serviceMatches = content.matchAll(/\[\[services\]\]\s*\n([^[]*)/g);
+  for (const match of serviceMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.services) result.services = [];
+      result.services.push({ binding: bindingMatch[1] });
+    }
+  }
+  const varsMatch = content.match(/\[vars\]\s*\n([^[]*)/s);
+  if (varsMatch) {
+    const varsSection = varsMatch[1];
+    const varMatches = varsSection.matchAll(/(\w+)\s*=\s*["']([^"']*)["']/g);
+    result.vars = {};
+    for (const match of varMatches) {
+      result.vars[match[1]] = match[2];
+    }
+  }
+  const aiMatch = content.match(/\[ai\]\s*\n([^[]*)/s);
+  if (aiMatch) {
+    const bindingMatch = aiMatch[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      result.ai = { binding: bindingMatch[1] };
+    }
+  }
+  const vectorizeMatches = content.matchAll(/\[\[vectorize\]\]\s*\n([^[]*)/g);
+  for (const match of vectorizeMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.vectorize) result.vectorize = [];
+      result.vectorize.push({ binding: bindingMatch[1] });
+    }
+  }
+  const hyperdriveMatches = content.matchAll(/\[\[hyperdrive\]\]\s*\n([^[]*)/g);
+  for (const match of hyperdriveMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.hyperdrive) result.hyperdrive = [];
+      result.hyperdrive.push({ binding: bindingMatch[1] });
+    }
+  }
+  return result;
+}
+function extractBindings(config) {
+  const bindings = [];
+  if (config.d1_databases) {
+    for (const db of config.d1_databases) {
+      bindings.push({ type: "d1", name: db.binding });
+    }
+  }
+  if (config.kv_namespaces) {
+    for (const kv of config.kv_namespaces) {
+      bindings.push({ type: "kv", name: kv.binding });
+    }
+  }
+  if (config.r2_buckets) {
+    for (const r2 of config.r2_buckets) {
+      bindings.push({ type: "r2", name: r2.binding });
+    }
+  }
+  if (config.queues?.producers) {
+    for (const queue of config.queues.producers) {
+      bindings.push({ type: "queue", name: queue.binding });
+    }
+  }
+  if (config.durable_objects?.bindings) {
+    for (const doBinding of config.durable_objects.bindings) {
+      bindings.push({ type: "do", name: doBinding.name });
+    }
+  }
+  if (config.services) {
+    for (const service of config.services) {
+      bindings.push({ type: "service", name: service.binding });
+    }
+  }
+  if (config.vars) {
+    for (const name of Object.keys(config.vars)) {
+      bindings.push({ type: "secret", name });
+    }
+  }
+  if (config.ai) {
+    bindings.push({ type: "ai", name: config.ai.binding });
+  }
+  if (config.vectorize) {
+    for (const vec of config.vectorize) {
+      bindings.push({ type: "vectorize", name: vec.binding });
+    }
+  }
+  if (config.hyperdrive) {
+    for (const hd of config.hyperdrive) {
+      bindings.push({ type: "hyperdrive", name: hd.binding });
+    }
+  }
+  return bindings;
+}
+function getSectionName(type) {
+  switch (type) {
+    case "d1":
+      return "D1 Databases";
+    case "kv":
+      return "KV Namespaces";
+    case "r2":
+      return "R2 Buckets";
+    case "queue":
+      return "Queues";
+    case "do":
+      return "Durable Objects";
+    case "service":
+      return "Services";
+    case "secret":
+      return "Environment Variables";
+    case "ai":
+      return "AI";
+    case "vectorize":
+      return "Vectorize Indexes";
+    case "hyperdrive":
+      return "Hyperdrive";
+    default:
+      return "Other";
+  }
+}
+function groupBindingsByType(bindings) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const binding of bindings) {
+    const existing = grouped.get(binding.type) || [];
+    existing.push(binding);
+    grouped.set(binding.type, existing);
+  }
+  return grouped;
+}
+function generateBindingsDts(bindings) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk - DO NOT EDIT");
+  lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("//");
+  lines.push("// This file provides type information for @cloudwerk/core/bindings");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/bindings' {");
+  const bindingsByType = groupBindingsByType(bindings);
+  const typeOrder = [
+    "d1",
+    "kv",
+    "r2",
+    "queue",
+    "do",
+    "service",
+    "ai",
+    "vectorize",
+    "hyperdrive",
+    "secret"
+  ];
+  let firstSection = true;
+  for (const type of typeOrder) {
+    const typeBindings = bindingsByType.get(type);
+    if (!typeBindings || typeBindings.length === 0) continue;
+    const tsType = TYPE_MAPPINGS[type];
+    const sectionName = getSectionName(type);
+    if (!firstSection) {
+      lines.push("");
+    }
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  export const ${binding.name}: ${tsType}`);
+    }
+  }
+  lines.push("");
+  lines.push("  // Bindings proxy object (for dynamic access)");
+  lines.push("  export const bindings: Record<string, unknown>");
+  lines.push("");
+  lines.push("  // Helper functions");
+  lines.push("  export function getBinding<T = unknown>(name: string): T");
+  lines.push("  export function hasBinding(name: string): boolean");
+  lines.push("  export function getBindingNames(): string[]");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateContextDts(bindings) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk - DO NOT EDIT");
+  lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("//");
+  lines.push("// This file provides type information for @cloudwerk/core/context");
+  lines.push("");
+  lines.push("interface CloudwerkEnv {");
+  const bindingsByType = groupBindingsByType(bindings);
+  const typeOrder = [
+    "d1",
+    "kv",
+    "r2",
+    "queue",
+    "do",
+    "service",
+    "ai",
+    "vectorize",
+    "hyperdrive",
+    "secret"
+  ];
+  let firstSection = true;
+  for (const type of typeOrder) {
+    const typeBindings = bindingsByType.get(type);
+    if (!typeBindings || typeBindings.length === 0) continue;
+    const tsType = TYPE_MAPPINGS[type];
+    const sectionName = getSectionName(type);
+    if (!firstSection) {
+      lines.push("");
+    }
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  ${binding.name}: ${tsType}`);
+    }
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/context' {");
+  lines.push("  export const params: Record<string, string>");
+  lines.push("  export const request: Request");
+  lines.push("  export const env: CloudwerkEnv");
+  lines.push("  export const executionCtx: {");
+  lines.push("    waitUntil(promise: Promise<unknown>): void");
+  lines.push("    passThroughOnException(): void");
+  lines.push("  }");
+  lines.push("  export function getRequestId(): string");
+  lines.push("  export function get<T>(key: string): T | undefined");
+  lines.push("  export function set<T>(key: string, value: T): void");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function findWranglerTomlPath(root) {
+  const tomlPath = path2.join(root, "wrangler.toml");
+  if (fs.existsSync(tomlPath)) {
+    return tomlPath;
+  }
+  const jsonPath = path2.join(root, "wrangler.json");
+  if (fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+  return null;
+}
+function regenerateCloudwerkTypes(root) {
+  const wranglerPath = findWranglerTomlPath(root);
+  if (!wranglerPath) {
+    return null;
+  }
+  const content = fs.readFileSync(wranglerPath, "utf-8");
+  let config;
+  if (wranglerPath.endsWith(".json")) {
+    config = JSON.parse(content);
+  } else {
+    config = parseSimpleToml(content);
+  }
+  const bindings = extractBindings(config);
+  if (bindings.length === 0) {
+    return null;
+  }
+  const typesDir = path2.join(root, ".cloudwerk", "types");
+  fs.mkdirSync(typesDir, { recursive: true });
+  const bindingsPath = path2.join(typesDir, "bindings.d.ts");
+  const bindingsContent = generateBindingsDts(bindings);
+  fs.writeFileSync(bindingsPath, bindingsContent, "utf-8");
+  const contextPath = path2.join(typesDir, "context.d.ts");
+  const contextContent = generateContextDts(bindings);
+  fs.writeFileSync(contextPath, contextContent, "utf-8");
+  return {
+    bindingCount: bindings.length,
+    files: {
+      bindings: bindingsPath,
+      context: contextPath
+    }
+  };
+}
+
 // src/plugin.ts
 async function scanClientComponents(root, state) {
-  const appDir = path2.resolve(root, state.options.appDir);
+  const appDir = path3.resolve(root, state.options.appDir);
   try {
-    await fs.promises.access(appDir);
+    await fs2.promises.access(appDir);
   } catch {
     return;
   }
   async function scanDir(dir) {
-    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
     await Promise.all(
       entries.map(async (entry) => {
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path3.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
             await scanDir(fullPath);
           }
         } else if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
-          const content = await fs.promises.readFile(fullPath, "utf-8");
+          const content = await fs2.promises.readFile(fullPath, "utf-8");
           if (hasUseClientDirective(content)) {
             const componentId = generateComponentId(fullPath, root);
             const bundlePath = `${state.options.hydrationEndpoint}/${componentId}.js`;
@@ -1106,9 +1439,9 @@ function cloudwerkPlugin(options = {}) {
   }
   function isRouteFile(filePath) {
     if (!state) return false;
-    const appDir = path2.resolve(state.options.root, state.options.appDir);
+    const appDir = path3.resolve(state.options.root, state.options.appDir);
     if (!filePath.startsWith(appDir)) return false;
-    const basename2 = path2.basename(filePath);
+    const basename2 = path3.basename(filePath);
     const nameWithoutExt = basename2.replace(/\.(ts|tsx|js|jsx)$/, "");
     return ROUTE_FILE_NAMES.includes(nameWithoutExt);
   }
@@ -1148,16 +1481,16 @@ function cloudwerkPlugin(options = {}) {
      */
     async configResolved(config) {
       const root = config.root;
-      let detectedServerEntry = options.serverEntry ? path2.resolve(root, options.serverEntry) : null;
+      let detectedServerEntry = options.serverEntry ? path3.resolve(root, options.serverEntry) : null;
       if (!detectedServerEntry) {
         const conventionalPaths = [
-          path2.resolve(root, "app/server.ts"),
-          path2.resolve(root, "app/server.tsx"),
-          path2.resolve(root, "src/server.ts"),
-          path2.resolve(root, "src/server.tsx")
+          path3.resolve(root, "app/server.ts"),
+          path3.resolve(root, "app/server.tsx"),
+          path3.resolve(root, "src/server.ts"),
+          path3.resolve(root, "src/server.tsx")
         ];
         for (const p of conventionalPaths) {
-          if (fs.existsSync(p)) {
+          if (fs2.existsSync(p)) {
             detectedServerEntry = p;
             if (options.verbose) {
               console.log(`[cloudwerk] Detected custom server entry: ${p}`);
@@ -1215,11 +1548,13 @@ function cloudwerkPlugin(options = {}) {
     configureServer(devServer) {
       server = devServer;
       if (!state) return;
-      const appDir = path2.resolve(state.options.root, state.options.appDir);
+      const appDir = path3.resolve(state.options.root, state.options.appDir);
+      const root = state.options.root;
+      const verbose = state.options.verbose;
       devServer.watcher.on("add", async (filePath) => {
         if (isRouteFile(filePath)) {
           if (state?.options.verbose) {
-            console.log(`[cloudwerk] Route added: ${path2.relative(appDir, filePath)}`);
+            console.log(`[cloudwerk] Route added: ${path3.relative(appDir, filePath)}`);
           }
           await buildManifest(state.options.root);
           invalidateVirtualModules();
@@ -1228,7 +1563,7 @@ function cloudwerkPlugin(options = {}) {
       devServer.watcher.on("unlink", async (filePath) => {
         if (isRouteFile(filePath)) {
           if (state?.options.verbose) {
-            console.log(`[cloudwerk] Route removed: ${path2.relative(appDir, filePath)}`);
+            console.log(`[cloudwerk] Route removed: ${path3.relative(appDir, filePath)}`);
           }
           await buildManifest(state.options.root);
           invalidateVirtualModules();
@@ -1237,12 +1572,26 @@ function cloudwerkPlugin(options = {}) {
       devServer.watcher.on("change", async (filePath) => {
         if (isRouteFile(filePath)) {
           if (state?.options.verbose) {
-            console.log(`[cloudwerk] Route changed: ${path2.relative(appDir, filePath)}`);
+            console.log(`[cloudwerk] Route changed: ${path3.relative(appDir, filePath)}`);
           }
           await buildManifest(state.options.root);
           invalidateVirtualModules();
         }
+        const wranglerPath2 = findWranglerTomlPath(root);
+        if (wranglerPath2 && filePath === wranglerPath2) {
+          if (verbose) {
+            console.log(`[cloudwerk] wrangler.toml changed, regenerating types...`);
+          }
+          const result = regenerateCloudwerkTypes(root);
+          if (result && verbose) {
+            console.log(`[cloudwerk] Regenerated .cloudwerk/types/ with ${result.bindingCount} binding(s)`);
+          }
+        }
       });
+      const wranglerPath = findWranglerTomlPath(root);
+      if (wranglerPath) {
+        devServer.watcher.add(wranglerPath);
+      }
     },
     /**
      * Resolve virtual module IDs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/vite-plugin",
-  "version": "0.4.0",
+  "version": "0.5.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.9.0",
-    "@cloudwerk/ui": "^0.9.0"
+    "@cloudwerk/core": "^0.12.0",
+    "@cloudwerk/ui": "^0.12.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0",