feat(export): enrich littlehorse scaffold

Author: DKFuH

src/export-littlehorse.js

@@ -13,19 +13,29 @@ function toLittleHorseSkeleton(model) {
 
   processes.forEach((processNode) => {
     const className = sanitizeClassName(processNode.name);
-    lines.push(`public class ${className}Workflow {`);
+    const workflowName = toKebabName(processNode.name);
+    lines.push(`public final class ${className}Workflow {`);
     lines.push("  // TODO: adapt this skeleton to your LittleHorse SDK version.");
-    lines.push("  public void buildWorkflow() {");
-    lines.push(`    // Process: ${processNode.name}`);
-    lines.push("    // TODO: declare variables and task definitions");
+    lines.push("  public static Workflow getWorkflow() {");
+    lines.push(`    return new WorkflowImpl("${workflowName}", wf -> {`);
+    lines.push(`      // Process: ${processNode.name}`);
+    const declarations = renderDeclarations(processNode.body || [], 6);
+    if (declarations.length > 0) {
+      lines.push("      // TODO: declare variables and task definitions");
+      lines.push(...declarations);
+      lines.push("");
+    } else {
+      lines.push("      // TODO: declare variables and task definitions");
+    }
 
-    const bodyLines = renderStatements(processNode.body || [], 4);
+    const bodyLines = renderStatements(processNode.body || [], 6);
     if (bodyLines.length > 0) {
       lines.push(...bodyLines);
     } else {
-      lines.push("    // TODO: add workflow steps");
+      lines.push("      // TODO: add workflow steps");
     }
 
+    lines.push("    });");
     lines.push("  }");
     lines.push("}");
     lines.push("");
@@ -34,6 +44,134 @@ function toLittleHorseSkeleton(model) {
   return `${lines.join("\n").trimEnd()}\n`;
 }
 
+function renderDeclarations(statements, indentSize) {
+  const indent = " ".repeat(indentSize);
+  const entries = collectFieldUsage(statements);
+  const lines = [];
+
+  for (const entry of entries) {
+    const decl = renderDeclaration(entry);
+    if (decl) {
+      lines.push(`${indent}${decl}`);
+    }
+  }
+
+  return lines;
+}
+
+function collectFieldUsage(statements, usage = new Map()) {
+  for (const statement of statements) {
+    if (statement.type === "when") {
+      continue;
+    }
+
+    if (statement.type === "if") {
+      collectConditionUsage(statement.condition, usage);
+      collectFieldUsage(statement.then || [], usage);
+      for (const branch of statement.elseIf || []) {
+        collectConditionUsage(branch.condition, usage);
+        collectFieldUsage(branch.then || [], usage);
+      }
+      if (statement.else && Array.isArray(statement.else.body)) {
+        collectFieldUsage(statement.else.body, usage);
+      }
+      continue;
+    }
+
+    if (statement.type === "assign" || statement.type === "transition" || statement.type === "update") {
+      recordField(usage, statement.target, statement.value);
+      continue;
+    }
+
+    if (statement.type === "notify") {
+      continue;
+    }
+
+    if (statement.type === "create") {
+      continue;
+    }
+
+    if (statement.type === "require") {
+      continue;
+    }
+  }
+
+  return Array.from(usage.values());
+}
+
+function collectConditionUsage(condition, usage) {
+  if (!condition) {
+    return;
+  }
+
+  if (condition.type === "logical") {
+    for (const child of condition.conditions || []) {
+      collectConditionUsage(child, usage);
+    }
+    return;
+  }
+
+  if (condition.left && condition.left.type === "field") {
+    recordField(usage, condition.left.path, condition.right);
+  }
+}
+
+function recordField(usage, path, value) {
+  if (!path) {
+    return;
+  }
+  const key = String(path);
+  const existing = usage.get(key);
+  const inferred = inferType(value);
+  if (!existing) {
+    usage.set(key, {
+      path: key,
+      type: inferred,
+    });
+    return;
+  }
+  existing.type = mergeTypes(existing.type, inferred);
+}
+
+function inferType(value) {
+  if (!value) {
+    return "string";
+  }
+  if (value.type === "number") {
+    return "number";
+  }
+  if (value.type === "boolean") {
+    return "boolean";
+  }
+  if (value.type === "string") {
+    return "string";
+  }
+  return "string";
+}
+
+function mergeTypes(existing, incoming) {
+  if (existing === incoming) {
+    return existing;
+  }
+  if (existing === "number" || incoming === "number") {
+    return "number";
+  }
+  if (existing === "boolean" || incoming === "boolean") {
+    return "boolean";
+  }
+  return "string";
+}
+
+function renderDeclaration(entry) {
+  const variableName = toVariableName(entry.path);
+  if (!variableName) {
+    return null;
+  }
+
+  const typeSuffix = entry.type === "number" ? "Double" : entry.type === "boolean" ? "Boolean" : "Str";
+  return `var ${variableName} = wf.declare${typeSuffix}("${variableName}");`;
+}
+
 function renderStatements(statements, indentSize) {
   const lines = [];
   const indent = " ".repeat(indentSize);
@@ -45,16 +183,17 @@ function renderStatements(statements, indentSize) {
     }
 
     if (statement.type === "if") {
-      lines.push(`${indent}// if ${formatCondition(statement.condition)}:`);
+      lines.push(`${indent}wf.doIf(/* ${formatCondition(statement.condition)} */, ifBody -> {`);
       lines.push(...renderStatements(statement.then || [], indentSize + 2));
+      lines.push(`${indent}});`);
 
       for (const branch of statement.elseIf || []) {
-        lines.push(`${indent}// else if ${formatCondition(branch.condition)}:`);
+        lines.push(`${indent}// else if ${formatCondition(branch.condition)} (map to doElseIf)`);
         lines.push(...renderStatements(branch.then || [], indentSize + 2));
       }
 
       if (statement.else && (statement.else.body || []).length > 0) {
-        lines.push(`${indent}// else:`);
+        lines.push(`${indent}// else (map to doElse)`);
         lines.push(...renderStatements(statement.else.body || [], indentSize + 2));
       }
       continue;
@@ -65,38 +204,48 @@ function renderStatements(statements, indentSize) {
       continue;
     }
 
-    lines.push(`${indent}// ${formatAction(statement)}`);
+    const action = formatAction(statement);
+    if (action) {
+      lines.push(`${indent}${action}`);
+      continue;
+    }
+
+    lines.push(`${indent}// ${statement.type}`);
   }
 
   return lines;
 }
 
 function formatAction(statement) {
   if (statement.type === "assign") {
-    return `assign ${statement.target || "?"} = ${formatExpression(statement.value)}`;
+    return `// assign ${statement.target || "?"} = ${formatExpression(statement.value)}`;
   }
 
   if (statement.type === "transition") {
-    return `transition ${statement.target || "?"} -> ${formatExpression(statement.value)}`;
+    return `// transition ${statement.target || "?"} -> ${formatExpression(statement.value)}`;
   }
 
   if (statement.type === "notify") {
-    return `notify ${statement.target} "${statement.message}"`;
+    const target = statement.target || "target";
+    const message = statement.message ? `"${statement.message}"` : "\"message\"";
+    return `wf.execute("notify", "${target}", ${message});`;
   }
 
   if (statement.type === "create") {
-    return `create ${statement.entity}`;
+    const entity = statement.entity || "entity";
+    return `wf.execute("create", "${entity}");`;
   }
 
   if (statement.type === "update") {
-    return `update ${statement.target || "?"} = ${formatExpression(statement.value)}`;
+    return `wf.execute("update", "${statement.target || "target"}", ${formatExpression(statement.value)});`;
   }
 
   if (statement.type === "require") {
-    return `require ${statement.requirement}`;
+    const requirement = statement.requirement || "requirement";
+    return `wf.execute("require", "${requirement}");`;
   }
 
-  return statement.type;
+  return null;
 }
 
 function formatCondition(condition) {
@@ -146,6 +295,33 @@ function sanitizeClassName(value) {
   return safe.charAt(0).toUpperCase() + safe.slice(1);
 }
 
+function toKebabName(value) {
+  const raw = String(value || "workflow").trim();
+  if (!raw) {
+    return "workflow";
+  }
+  const spaced = raw.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+  return spaced
+    .replace(/[^A-Za-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+}
+
+function toVariableName(path) {
+  const value = String(path || "").trim();
+  if (!value) {
+    return null;
+  }
+  const sanitized = value.replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (!sanitized) {
+    return null;
+  }
+  if (/^[A-Za-z_]/.test(sanitized)) {
+    return sanitized;
+  }
+  return `var_${sanitized}`;
+}
+
 module.exports = {
   toLittleHorseSkeleton,
 };

tests/run.js

@@ -995,6 +995,7 @@ function testSkeletonExporters() {
 
   const littleHorse = toLittleHorseSkeleton(model);
   assert.ok(littleHorse.includes("OrderApprovalWorkflow"), "Expected LittleHorse class name");
+  assert.ok(littleHorse.includes("WorkflowImpl(\"order-approval\""), "Expected workflow name");
   assert.ok(littleHorse.includes("when order.submitted"), "Expected trigger comment");
 
   const graph = JSON.parse(toGraphJson(model));