@walkeros/cli 4.1.0-next-1778668930820 → 4.1.0

package/dist/index.js

@@ -1897,8 +1897,8 @@ import fs11 from "fs-extra";
 import {
   packageNameToVariable,
   ENV_MARKER_PREFIX,
-  validateTransformerEntry,
-  isPathTransformerEntry
+  validateStepEntry,
+  isPathStepEntry
 } from "@walkeros/core";
 import { getHashServer as getHashServer3 } from "@walkeros/server-core";
 function isInlineCode(code) {
@@ -1921,7 +1921,7 @@ function hasCodeReference(code) {
 }
 function validateReference(type, name, ref) {
   if (type === "Transformer") {
-    const r = validateTransformerEntry({ ...ref });
+    const r = validateStepEntry({ ...ref }, "Transformer");
     if (!r.ok) {
       throw new Error(`Transformer "${name}": ${r.reason ?? "invalid entry."}`);
     }
@@ -2034,8 +2034,7 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
         const varName = packageNameToVariable(pkg);
         if (!buildOptions.packages[varName]) {
           buildOptions.packages[varName] = {
-            path: pkg,
-            imports: [`default as ${varName}`]
+            path: pkg
           };
         }
         for (const section of [
@@ -2048,8 +2047,7 @@ async function bundleCore(flowSettings, buildOptions, logger, showStats = false)
           if (!steps) continue;
           for (const step of Object.values(steps)) {
             if (step.package === pkg) {
-              step.code = varName;
-              delete step.package;
+              step.package = varName;
             }
           }
         }
@@ -2502,67 +2500,27 @@ function collectAllStepPackages(flowSettings) {
   }
   return allPackages;
 }
-function detectExplicitCodeImports(flowSettings) {
-  const explicitCodeImports = /* @__PURE__ */ new Map();
-  const destinations = flowSettings.destinations;
-  if (destinations) {
-    for (const [, destConfig] of Object.entries(destinations)) {
-      if (typeof destConfig.package === "string" && typeof destConfig.code === "string") {
-        const isAutoGenerated = destConfig.code.startsWith("_");
-        if (!isAutoGenerated) {
-          if (!explicitCodeImports.has(destConfig.package)) {
-            explicitCodeImports.set(destConfig.package, /* @__PURE__ */ new Set());
-          }
-          explicitCodeImports.get(destConfig.package).add(destConfig.code);
-        }
-      }
-    }
-  }
-  const sources = flowSettings.sources;
-  if (sources) {
-    for (const [, sourceConfig] of Object.entries(sources)) {
-      if (typeof sourceConfig.package === "string" && typeof sourceConfig.code === "string") {
-        const isAutoGenerated = sourceConfig.code.startsWith("_");
-        if (!isAutoGenerated) {
-          if (!explicitCodeImports.has(sourceConfig.package)) {
-            explicitCodeImports.set(sourceConfig.package, /* @__PURE__ */ new Set());
-          }
-          explicitCodeImports.get(sourceConfig.package).add(sourceConfig.code);
-        }
-      }
-    }
-  }
-  const transformers = flowSettings.transformers;
-  if (transformers) {
-    for (const [, transformerConfig] of Object.entries(transformers)) {
-      if (typeof transformerConfig.package === "string" && typeof transformerConfig.code === "string") {
-        const isAutoGenerated = transformerConfig.code.startsWith("_");
-        if (!isAutoGenerated) {
-          if (!explicitCodeImports.has(transformerConfig.package)) {
-            explicitCodeImports.set(transformerConfig.package, /* @__PURE__ */ new Set());
-          }
-          explicitCodeImports.get(transformerConfig.package).add(transformerConfig.code);
-        }
-      }
-    }
-  }
-  const stores = flowSettings.stores;
-  if (stores) {
-    for (const [, storeConfig] of Object.entries(stores)) {
-      if (typeof storeConfig.package === "string" && typeof storeConfig.code === "string") {
-        const isAutoGenerated = storeConfig.code.startsWith("_");
-        if (!isAutoGenerated) {
-          if (!explicitCodeImports.has(storeConfig.package)) {
-            explicitCodeImports.set(storeConfig.package, /* @__PURE__ */ new Set());
-          }
-          explicitCodeImports.get(storeConfig.package).add(storeConfig.code);
-        }
+function detectNamedImports(flowSettings) {
+  const namedImports = /* @__PURE__ */ new Map();
+  const addNamed = (pkg, importName) => {
+    if (!namedImports.has(pkg)) namedImports.set(pkg, /* @__PURE__ */ new Set());
+    namedImports.get(pkg).add(importName);
+  };
+  const visit = (bucket) => {
+    if (!bucket) return;
+    for (const step of Object.values(bucket)) {
+      if (typeof step.package === "string" && typeof step.import === "string") {
+        addNamed(step.package, step.import);
       }
     }
-  }
-  return explicitCodeImports;
+  };
+  visit(flowSettings.sources);
+  visit(flowSettings.destinations);
+  visit(flowSettings.transformers);
+  visit(flowSettings.stores);
+  return namedImports;
 }
-async function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, storePackages, explicitCodeImports, packagePaths, withDev) {
+async function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, storePackages, namedImports, packagePaths, withDev) {
   const importStatements = [];
   const usedPackages = /* @__PURE__ */ new Set([
     ...destinationPackages,
@@ -2572,21 +2530,21 @@ async function generateImportStatements(packages, destinationPackages, sourcePac
   ]);
   for (const [packageName, packageConfig] of Object.entries(packages)) {
     const isUsedByDestOrSource = usedPackages.has(packageName);
-    const hasExplicitCode = explicitCodeImports.has(packageName);
+    const hasNamed = namedImports.has(packageName);
     const namedImportsToGenerate = [];
-    if (isUsedByDestOrSource && !hasExplicitCode) {
+    if (isUsedByDestOrSource && !hasNamed) {
       const varName = packageNameToVariable(packageName);
       importStatements.push(`import ${varName} from '${packageName}';`);
     }
-    if (hasExplicitCode) {
-      const codes = Array.from(explicitCodeImports.get(packageName));
+    if (hasNamed) {
+      const codes = Array.from(namedImports.get(packageName));
       namedImportsToGenerate.push(...codes);
     }
     if (packageConfig.imports && packageConfig.imports.length > 0) {
       const uniqueImports = [...new Set(packageConfig.imports)];
       for (const imp of uniqueImports) {
         if (imp.startsWith("default as ")) {
-          if (!isUsedByDestOrSource || hasExplicitCode) {
+          if (!isUsedByDestOrSource || hasNamed) {
             const defaultImportName = imp.replace("default as ", "");
             importStatements.push(
               `import ${defaultImportName} from '${packageName}';`
@@ -2674,7 +2632,7 @@ async function createEntryPoint(flowSettings, buildOptions, packagePaths) {
   const destinationPackages = detectStepPackages(flowSettings, "destinations");
   const transformerPackages = detectStepPackages(flowSettings, "transformers");
   const storePackages = detectStepPackages(flowSettings, "stores");
-  const explicitCodeImports = detectExplicitCodeImports(flowSettings);
+  const namedImports = detectNamedImports(flowSettings);
   const storeIds = new Set(Object.keys(flowSettings.stores || {}));
   validateStoreReferences(flowSettings, storeIds);
   if (flowSettings.sources)
@@ -2692,7 +2650,7 @@ async function createEntryPoint(flowSettings, buildOptions, packagePaths) {
     sourcePackages,
     transformerPackages,
     storePackages,
-    explicitCodeImports,
+    namedImports,
     packagePaths,
     withDev
   );
@@ -2712,7 +2670,7 @@ ${userCode}` : userCode,
       hasFlow: false
     };
   }
-  const { storesDeclaration, codeConfigObject, dataPayload } = buildSplitConfigObject(flowSettings, explicitCodeImports);
+  const { storesDeclaration, codeConfigObject, dataPayload } = buildSplitConfigObject(flowSettings, namedImports);
   const wireConfigModule = generateSplitWireConfigModule(
     storesDeclaration,
     codeConfigObject,
@@ -2751,25 +2709,22 @@ ${firstError.text}`
 ` + (location ? `  at ${location.file}:${location.line}:${location.column}` : "")
   );
 }
-function buildSplitConfigObject(flowSettings, explicitCodeImports) {
+function buildSplitConfigObject(flowSettings, namedImports) {
   const sources = flowSettings.sources || {};
   const destinations = flowSettings.destinations || {};
   const transformers = flowSettings.transformers || {};
   const stores = flowSettings.stores || {};
   const dataPayloadObj = {};
   function resolveCodeVar(step) {
-    if (step.code && typeof step.code === "string" && !step.package) {
-      return step.code;
-    }
-    if (step.code && typeof step.code === "string" && step.package && explicitCodeImports.has(step.package)) {
-      return step.code;
+    if (typeof step.import === "string" && step.package) {
+      return step.import;
     }
     return packageNameToVariable(step.package);
   }
   function getStepProps(step) {
     const props = {};
     for (const [key, value] of Object.entries(step)) {
-      if (key === "code" || key === "package") continue;
+      if (key === "code" || key === "package" || key === "import") continue;
       if (value !== void 0 && value !== null) {
         props[key] = value;
       }
@@ -2819,12 +2774,12 @@ function buildSplitConfigObject(flowSettings, explicitCodeImports) {
     return buildSplitStepEntry("destinations", key, dest);
   });
   const transformersEntries = Object.entries(transformers).filter(
-    ([, transformer]) => transformer.package || hasCodeReference(transformer.code) || isPathTransformerEntry({ ...transformer })
+    ([, transformer]) => transformer.package || hasCodeReference(transformer.code) || isPathStepEntry({ ...transformer }, "Transformer")
   ).map(([key, transformer]) => {
     if (isInlineCode(transformer.code)) {
       return `    ${key}: ${generateInlineCode(transformer.code, transformer.config || {}, transformer.env, { before: transformer.before, next: transformer.next })}`;
     }
-    if (isPathTransformerEntry({ ...transformer })) {
+    if (isPathStepEntry({ ...transformer }, "Transformer")) {
       const chainLines = [];
       if (transformer.before !== void 0) {
         chainLines.push(`before: ${JSON.stringify(transformer.before)}`);
@@ -3622,16 +3577,13 @@ import fs15 from "fs-extra";
 import {
   createIngest,
   getPlatform as getPlatform3,
-  compileNext,
-  resolveNext,
+  getNextSteps,
   buildCacheContext
 } from "@walkeros/core";
 import {
   transformerInit,
   transformerPush,
   runTransformerChain,
-  walkChain,
-  extractTransformerNextMap,
   wrapEnv
 } from "@walkeros/collector";
 
@@ -4318,14 +4270,39 @@ async function runDestinationSimulationLoop(config, event, destinationIds, optio
 function isRecord(value) {
   return value !== null && typeof value === "object";
 }
+function isString(value) {
+  return typeof value === "string";
+}
+function walkStaticChain(startId, transformers) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = startId;
+  while (current && transformers[current]) {
+    if (visited.has(current)) break;
+    visited.add(current);
+    chain.push(current);
+    const next = transformers[current].config?.next;
+    if (typeof next === "string") {
+      current = next;
+      continue;
+    }
+    if (Array.isArray(next) && next.every(isString)) {
+      chain.push(...next);
+      break;
+    }
+    break;
+  }
+  return chain;
+}
 function resolveBeforeChain(before, transformers, ingest, event) {
   if (!before) return [];
-  const resolved = resolveNext(
-    compileNext(before),
-    buildCacheContext(ingest, event)
-  );
-  if (!resolved) return [];
-  return walkChain(resolved, extractTransformerNextMap(transformers));
+  if (Array.isArray(before) && before.every(isString)) {
+    return before;
+  }
+  const ids = getNextSteps(before, buildCacheContext(ingest, event));
+  if (ids.length === 0) return [];
+  if (ids.length === 1) return walkStaticChain(ids[0], transformers);
+  return ids;
 }
 async function pushCore(inputPath, event, options = {}) {
   const logger = createCLILogger({
@@ -6049,11 +6026,7 @@ function validateEvent2(input) {
 }
 
 // src/commands/validate/validators/flow.ts
-import {
-  getFlowSettings as getFlowSettings2,
-  isObject as isObject2,
-  validateTransformerEntry as validateTransformerEntry2
-} from "@walkeros/core";
+import { getFlowSettings as getFlowSettings2, isObject as isObject2, validateStepEntry as validateStepEntry2 } from "@walkeros/core";
 import { schemas as schemas4 } from "@walkeros/core/dev";
 var { validateFlowConfig: validateFlowConfig2 } = schemas4;
 function isFlowJson(value) {
@@ -6109,7 +6082,7 @@ function validateFlow(input, options = {}) {
         transformersValue
       )) {
         if (!isObject2(transformerValue)) continue;
-        const result = validateTransformerEntry2(transformerValue);
+        const result = validateStepEntry2(transformerValue, "Transformer");
         if (!result.ok) {
           errors.push({
             path: `flows.${flowName}.transformers.${name}`,
@@ -6206,6 +6179,15 @@ function validateFlow(input, options = {}) {
       }
     }
   }
+  if (errors.length === 0 && isFlowJson(input)) {
+    const typedFlows = input.flows;
+    const flowsToLint = options.flow ? options.flow in typedFlows ? [options.flow] : [] : Object.keys(typedFlows);
+    for (const name of flowsToLint) {
+      const flowSettings = typedFlows[name];
+      if (!flowSettings) continue;
+      lintFlowRoutes(name, flowSettings, warnings);
+    }
+  }
   if (errors.length === 0 && isFlowJson(input)) {
     const flowsMap = input.flows;
     const flowsToResolve = options.flow ? options.flow in flowsMap ? [options.flow] : [] : Object.keys(flowsMap);
@@ -6239,31 +6221,42 @@ function validateFlow(input, options = {}) {
     details
   };
 }
+function isRouteConfig(spec) {
+  return typeof spec === "object" && spec !== null && !Array.isArray(spec);
+}
+function isRouteNext(spec) {
+  if (!("next" in spec)) return false;
+  const value = spec.next;
+  return value !== void 0;
+}
+function isRouteOne(spec) {
+  if (!("one" in spec)) return false;
+  const value = spec.one;
+  return Array.isArray(value);
+}
+function isRouteMany(spec) {
+  if (!("many" in spec)) return false;
+  const value = spec.many;
+  return Array.isArray(value);
+}
 function flattenRouteTargets(spec) {
   if (!spec) return [];
   if (typeof spec === "string") return [spec];
-  if (!Array.isArray(spec) && typeof spec === "object") {
-    const cfg = spec;
-    if ("next" in cfg && cfg.next !== void 0)
-      return flattenRouteTargets(cfg.next);
-    if ("case" in cfg && cfg.case) {
-      return Array.from(new Set(cfg.case.flatMap(flattenRouteTargets)));
+  if (isRouteConfig(spec)) {
+    if (isRouteNext(spec)) return flattenRouteTargets(spec.next);
+    if (isRouteOne(spec)) {
+      return Array.from(new Set(spec.one.flatMap(flattenRouteTargets)));
+    }
+    if (isRouteMany(spec)) {
+      return Array.from(new Set(spec.many.flatMap(flattenRouteTargets)));
     }
     return [];
   }
-  if (Array.isArray(spec) && spec.length === 0) return [];
+  if (spec.length === 0) return [];
   if (typeof spec[0] === "string") {
     return spec.filter((s) => typeof s === "string");
   }
-  return Array.from(
-    new Set(
-      spec.flatMap(
-        (entry) => flattenRouteTargets(
-          entry
-        )
-      )
-    )
-  );
+  return Array.from(new Set(spec.flatMap(flattenRouteTargets)));
 }
 function buildConnectionGraph(config) {
   const connections = [];
@@ -6366,6 +6359,89 @@ function isStructurallyCompatible(a, b) {
   }
   return true;
 }
+function lintFlowRoutes(flowName, flow, warnings) {
+  for (const [name, source] of Object.entries(flow.sources || {})) {
+    lintRoute(source.next, `flows.${flowName}.sources.${name}.next`, warnings);
+    lintRoute(
+      source.before,
+      `flows.${flowName}.sources.${name}.before`,
+      warnings
+    );
+  }
+  for (const [name, transformer] of Object.entries(flow.transformers || {})) {
+    lintRoute(
+      transformer.next,
+      `flows.${flowName}.transformers.${name}.next`,
+      warnings
+    );
+    lintRoute(
+      transformer.before,
+      `flows.${flowName}.transformers.${name}.before`,
+      warnings
+    );
+  }
+  for (const [name, dest] of Object.entries(flow.destinations || {})) {
+    lintRoute(
+      dest.before,
+      `flows.${flowName}.destinations.${name}.before`,
+      warnings
+    );
+    lintRoute(
+      dest.next,
+      `flows.${flowName}.destinations.${name}.next`,
+      warnings
+    );
+  }
+}
+function lintRoute(spec, position, warnings) {
+  if (!spec) return;
+  if (typeof spec === "string") return;
+  if (Array.isArray(spec)) {
+    for (let i = 0; i < spec.length; i++) {
+      const entry = spec[i];
+      if (i < spec.length - 1 && typeof entry === "object" && entry !== null && !Array.isArray(entry) && isRouteMany(entry)) {
+        warnings.push({
+          path: position,
+          message: `dead code after many at ${position}: main chain terminates at the many operator`,
+          suggestion: "Remove entries after the many operator; move them into each many branch if they should still run."
+        });
+      }
+      lintRoute(entry, `${position}[${i}]`, warnings);
+    }
+    return;
+  }
+  if (isRouteNext(spec)) {
+    lintRoute(spec.next, `${position}.next`, warnings);
+    return;
+  }
+  if (isRouteOne(spec)) {
+    for (let i = 0; i < spec.one.length; i++) {
+      lintRoute(spec.one[i], `${position}.one[${i}]`, warnings);
+    }
+    return;
+  }
+  if (isRouteMany(spec)) {
+    if (spec.many.length === 0) {
+      warnings.push({
+        path: position,
+        message: `empty many at ${position}: main chain terminates with no branches; use next or remove`,
+        suggestion: "Add one or more branch targets to many, or replace many with next if no fan-out is needed."
+      });
+    } else if (spec.many.length === 1) {
+      const only = spec.many[0];
+      const hint = typeof only === "string" ? `use 'next: "${only}"' for clarity` : `use 'next' for clarity`;
+      warnings.push({
+        path: position,
+        message: `single-entry many at ${position}: ${hint}`,
+        suggestion: "Replace many with next when only one branch exists."
+      });
+    }
+    for (let i = 0; i < spec.many.length; i++) {
+      lintRoute(spec.many[i], `${position}.many[${i}]`, warnings);
+    }
+    return;
+  }
+}
 function checkContractCompliance(config, contract, warnings) {
   for (const [name, dest] of Object.entries(config.destinations || {})) {
     if (!dest.examples) continue;
@@ -6452,7 +6528,7 @@ function validateMapping(input) {
 // src/commands/validate/validators/entry.ts
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
-var CLIENT_HEADER = "walkeros-cli/4.1.0-next-1778668930820";
+var CLIENT_HEADER = "walkeros-cli/4.1.0";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path20, flowConfig) {
   const flows = flowConfig.flows;