@omg-dev/vite-plugin 0.4.24

package/src/scanner-workflows.ts

@@ -0,0 +1,125 @@
+// Workflow scanner — detects `workflow("…", fn)` call sites in functions/*.ts
+// and emits a registry consumed by @omg-dev/server (dev engine + prod Restate
+// endpoint) and the orchestrator (deployment registration at publish).
+//
+// Convention mirrors scanner-triggers.ts: a workflow MUST be a top-level
+// export with a string-literal first arg:
+//
+//   export const onboarding = workflow("onboarding", async (step, payload) => { ... })
+//
+// The name becomes the engine-side handler name. Restate rejects handler
+// names outside ^([a-zA-Z]|_[a-zA-Z0-9])[a-zA-Z0-9_]*$ at discovery time
+// (verified against 1.6.2 — dashes are NOT allowed), so we enforce
+// [A-Za-z][A-Za-z0-9_]* here and fail the build loudly — a publish-time
+// registration failure would strand every startWorkflow() call site.
+
+import fs from "node:fs"
+import path from "node:path"
+
+export interface ScannedWorkflow {
+  /** Workflow name — the literal first arg of workflow(). */
+  name: string
+  /** Dispatch identifier: "<file-basename>.<exportName>" (parity with triggers). */
+  handler: string
+  /** Absolute file path of the function module (for dev import). */
+  module: string
+  /** Exported binding name inside the module. */
+  exportName: string
+}
+
+const EXPORT_WORKFLOW_RE = /^export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*workflow\s*\(\s*(.+?)\s*,/gm
+
+const NAME_RE = /^[A-Za-z][A-Za-z0-9_]*$/
+
+export class WorkflowScanError extends Error {
+  constructor(public file: string, public detail: string) {
+    super(`[vibes:workflows] ${file}: ${detail}`)
+    this.name = "WorkflowScanError"
+  }
+}
+
+/** scanWorkflows walks `<root>/functions/` and returns every declared workflow. */
+export async function scanWorkflows(root: string): Promise<ScannedWorkflow[]> {
+  const fnDir = path.join(root, "functions")
+  if (!fs.existsSync(fnDir)) return []
+
+  const out: ScannedWorkflow[] = []
+  walk(fnDir, out)
+  const apiDir = path.join(fnDir, "api")
+  if (fs.existsSync(apiDir) && fs.statSync(apiDir).isDirectory()) {
+    walk(apiDir, out)
+  }
+
+  // Names key engine handlers + startWorkflow() lookups — duplicates would
+  // shadow each other. Fail loud at build time.
+  const seen = new Map<string, string>()
+  for (const w of out) {
+    const prev = seen.get(w.name)
+    if (prev) {
+      throw new WorkflowScanError(
+        w.module,
+        `duplicate workflow name "${w.name}" (also declared by ${prev})`,
+      )
+    }
+    seen.set(w.name, w.handler)
+  }
+  return out
+}
+
+function walk(dir: string, out: ScannedWorkflow[]): void {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) continue
+    if (!entry.name.endsWith(".ts") || entry.name.endsWith(".d.ts")) continue
+    const filePath = path.join(dir, entry.name)
+    const source = fs.readFileSync(filePath, "utf-8")
+    const basename = path.basename(entry.name, ".ts")
+    out.push(...extractWorkflows(source, filePath, basename))
+  }
+}
+
+export function extractWorkflows(source: string, filePath: string, basename: string): ScannedWorkflow[] {
+  const out: ScannedWorkflow[] = []
+  // Strip comments so commented-out declarations aren't picked up (same
+  // simple pass as scanner-triggers.ts).
+  const stripped = source
+    .replace(/\/\/.*$/gm, "")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+
+  let m: RegExpExecArray | null
+  EXPORT_WORKFLOW_RE.lastIndex = 0
+  while ((m = EXPORT_WORKFLOW_RE.exec(stripped)) !== null) {
+    const [, exportName, firstArg] = m
+    const lit = parseStringLiteral(firstArg!)
+    if (lit === null) {
+      throw new WorkflowScanError(
+        filePath,
+        `workflow() first arg must be a string literal — got: ${firstArg!.slice(0, 60)}`,
+      )
+    }
+    if (!NAME_RE.test(lit)) {
+      throw new WorkflowScanError(
+        filePath,
+        `workflow name "${lit}" is invalid — use [A-Za-z][A-Za-z0-9_]* (no dashes; it becomes the engine handler name)`,
+      )
+    }
+    out.push({
+      name: lit,
+      handler: `${basename}.${exportName!}`,
+      module: filePath,
+      exportName: exportName!,
+    })
+  }
+  return out
+}
+
+function parseStringLiteral(raw: string): string | null {
+  const trimmed = raw.trim()
+  if (trimmed.length < 2) return null
+  const first = trimmed[0]
+  if ((first === '"' || first === "'") && trimmed.endsWith(first)) {
+    const inner = trimmed.slice(1, -1)
+    if (inner.includes("${")) return null
+    return inner.replace(/\\(.)/g, "$1")
+  }
+  return null
+}

package/src/scanner.ts

@@ -0,0 +1,146 @@
+import fs from "node:fs"
+import path from "node:path"
+
+export interface Route {
+  method: string
+  path: string
+  module: string
+  handler: string
+  /**
+   * "crud"   — handler is invoked with the conventional (id?, body?) args.
+   *            handler name maps to an HTTP method via list/get/create/update/remove.
+   * "method" — handler is invoked with (req: Request, params). Used when the
+   *            exported name is an HTTP method (GET/POST/PUT/PATCH/DELETE)
+   *            and the handler should receive the raw Request — e.g. for
+   *            streaming responses, custom headers, or non-JSON bodies.
+   */
+  style?: "crud" | "method"
+}
+
+const HTTP_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"])
+
+function handlerToRoute(routePath: string, handlerName: string, modulePath: string): Route {
+  // Method-named exports — receive the raw Request, route by HTTP method on
+  // the resource path itself (no /:name suffix). This is what unlocks
+  // streaming handlers that previously had to live in a separate Bun.serve.
+  if (HTTP_METHODS.has(handlerName)) {
+    return {
+      method: handlerName,
+      path: routePath,
+      module: modulePath,
+      handler: handlerName,
+      style: "method",
+    }
+  }
+  // CRUD convention.
+  switch (handlerName) {
+    case "list":   return { method: "GET",    path: routePath,           module: modulePath, handler: handlerName, style: "crud" }
+    case "get":    return { method: "GET",    path: `${routePath}/:id`,  module: modulePath, handler: handlerName, style: "crud" }
+    case "create": return { method: "POST",   path: routePath,           module: modulePath, handler: handlerName, style: "crud" }
+    case "update": return { method: "PATCH",  path: `${routePath}/:id`,  module: modulePath, handler: handlerName, style: "crud" }
+    case "remove": return { method: "DELETE", path: `${routePath}/:id`,  module: modulePath, handler: handlerName, style: "crud" }
+    default:       return { method: "POST",   path: `${routePath}/${handlerName}`, module: modulePath, handler: handlerName, style: "crud" }
+  }
+}
+
+// ── scanFunctions ─────────────────────────────────────────────────────────────
+
+/**
+ * Scans the `functions/` directory in `dir` and returns a list of routes.
+ *
+ * Layout:
+ *   functions/<name>.ts        → routes mounted at /api/<name>
+ *   functions/api/<name>.ts    → routes mounted at /api/<name>  (the `api/`
+ *                                 subdir is treated as a no-op prefix so the
+ *                                 path doesn't double up to /api/api/<name>;
+ *                                 lets people group "raw HTTP" handlers
+ *                                 alongside CRUD without an ugly URL).
+ *
+ * Uses regex to extract exported function names — no AST parser needed.
+ */
+export async function scanFunctions(dir: string): Promise<Route[]> {
+  const functionsDir = path.join(dir, "functions")
+  if (!fs.existsSync(functionsDir)) return []
+
+  const routes: Route[] = []
+
+  // Top-level: functions/<name>.ts
+  walkDir(functionsDir, "/api", routes, /* skipDirName */ "api")
+
+  // Nested: functions/api/<name>.ts — treated as if it were at the root of
+  // functions/ so paths stay /api/<name> rather than /api/api/<name>.
+  const apiDir = path.join(functionsDir, "api")
+  if (fs.existsSync(apiDir) && fs.statSync(apiDir).isDirectory()) {
+    walkDir(apiDir, "/api", routes, /* skipDirName */ null)
+  }
+
+  return routes
+}
+
+function walkDir(
+  fullDir: string,
+  routePrefix: string,
+  routes: Route[],
+  skipDirName: string | null,
+): void {
+  const entries = fs.readdirSync(fullDir, { withFileTypes: true })
+  for (const entry of entries) {
+    if (entry.isDirectory()) continue           // nested dirs handled separately
+    if (skipDirName && entry.name === skipDirName) continue
+    if (!entry.name.endsWith(".ts") || entry.name.endsWith(".d.ts")) continue
+
+    const filePath = path.join(fullDir, entry.name)
+    const resource = path.basename(entry.name, ".ts")
+    const source = fs.readFileSync(filePath, "utf-8")
+    const handlerNames = extractExports(source)
+
+    for (const handlerName of handlerNames) {
+      routes.push(handlerToRoute(`${routePrefix}/${resource}`, handlerName, filePath))
+    }
+  }
+}
+
+// ── extractExports ────────────────────────────────────────────────────────────
+
+/**
+ * Extracts exported function/const names from TypeScript source using regex.
+ */
+export function extractExports(source: string): string[] {
+  const names: string[] = []
+  const seen = new Set<string>()
+
+  // Match: export async function name / export function name
+  const fnRegex = /^export\s+(?:async\s+)?function\s+(\w+)/gm
+  let match: RegExpExecArray | null
+  while ((match = fnRegex.exec(source)) !== null) {
+    const name = match[1]
+    if (!seen.has(name)) {
+      seen.add(name)
+      names.push(name)
+    }
+  }
+
+  // Match: export const name = / export const name: Type =
+  const constRegex = /^export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=/gm
+  while ((match = constRegex.exec(source)) !== null) {
+    const name = match[1]
+    if (!seen.has(name)) {
+      seen.add(name)
+      names.push(name)
+    }
+  }
+
+  // Match: export { name, name2 }
+  const namedExportRegex = /^export\s*\{([^}]+)\}/gm
+  while ((match = namedExportRegex.exec(source)) !== null) {
+    const exports = match[1].split(",").map(s => s.trim().split(/\s+as\s+/).pop()!.trim())
+    for (const name of exports) {
+      if (name && !seen.has(name)) {
+        seen.add(name)
+        names.push(name)
+      }
+    }
+  }
+
+  return names
+}