@walkeros/cli 1.0.2 → 1.1.0-next-1769691037535

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @walkeros/cli
 
+## 1.1.0-next-1769691037535
+
+### Minor Changes
+
+- 888bbdf: Add inline code syntax for sources, transformers, and destinations
+
+  Enables defining custom logic directly in flow.json using `code` objects
+  instead of requiring external packages. This is ideal for simple one-liner
+  transformations.
+
+  **Example:**
+
+  ```json
+  {
+    "transformers": {
+      "enrich": {
+        "code": {
+          "push": "$code:(event) => ({ ...event, data: { ...event.data, enriched: true } })"
+        },
+        "config": {}
+      }
+    }
+  }
+  ```
+
+  **Code object properties:**
+  - `push` - The push function with `$code:` prefix (required)
+  - `type` - Optional instance type identifier
+  - `init` - Optional init function with `$code:` prefix
+
+  **Rules:**
+  - Use `package` OR `code`, never both (CLI validates this)
+  - `config` stays separate from `code`
+  - `$code:` prefix outputs raw JavaScript at bundle time
+
+### Patch Changes
+
+- fdf6e7b: Add transformer support to CLI bundler
+  - Detect and bundle transformer packages from flow.json configuration
+  - Support transformer chaining via `next` field
+  - Handle `$code:` prefix for inline JavaScript in transformer config
+  - Generate proper import statements and config objects for transformers
+  - Document transformer configuration in flow.json
+
+- Updated dependencies [f39d9fb]
+- Updated dependencies [888bbdf]
+  - @walkeros/core@1.2.0-next-1769691037535
+  - @walkeros/server-core@1.0.2-next-1769691037535
+
 ## 1.0.2
 
 ### Patch Changes

package/dist/index.js

@@ -807,6 +807,51 @@ async function getCachedBuild(configContent, tmpDir) {
 }
 
 // src/commands/bundle/bundler.ts
+function isInlineCode(code) {
+  return code !== null && typeof code === "object" && "push" in code;
+}
+function validateReference(type, name, ref) {
+  const hasPackage = !!ref.package;
+  const hasCode = isInlineCode(ref.code);
+  if (hasPackage && hasCode) {
+    throw new Error(
+      `${type} "${name}": Cannot specify both package and code. Use one or the other.`
+    );
+  }
+  if (!hasPackage && !hasCode) {
+    throw new Error(`${type} "${name}": Must specify either package or code.`);
+  }
+}
+function generateInlineCode(inline, config) {
+  const pushFn = inline.push.replace("$code:", "");
+  const initFn = inline.init ? inline.init.replace("$code:", "") : void 0;
+  const typeLine = inline.type ? `type: '${inline.type}',` : "";
+  return `{
+      code: async (context) => ({
+        ${typeLine}
+        config: context.config,
+        ${initFn ? `init: ${initFn},` : ""}
+        push: ${pushFn}
+      }),
+      config: ${JSON.stringify(config || {})},
+      env: {}
+    }`;
+}
+function generateInlineDestinationCode(inline, config) {
+  const pushFn = inline.push.replace("$code:", "");
+  const initFn = inline.init ? inline.init.replace("$code:", "") : void 0;
+  const typeLine = inline.type ? `type: '${inline.type}',` : "";
+  return `{
+      code: {
+        ${typeLine}
+        config: ${JSON.stringify(config || {})},
+        ${initFn ? `init: ${initFn},` : ""}
+        push: ${pushFn}
+      },
+      config: ${JSON.stringify(config || {})},
+      env: {}
+    }`;
+}
 async function copyIncludes(includes, sourceDir, outputDir, logger2) {
   for (const include of includes) {
     const sourcePath = path8.resolve(sourceDir, include);
@@ -832,8 +877,48 @@ function generateCacheKeyContent(flowConfig, buildOptions) {
   };
   return JSON.stringify(configForCache);
 }
+function validateFlowConfig(flowConfig, logger2) {
+  let hasDeprecatedCodeTrue = false;
+  const sources = flowConfig.sources || {};
+  for (const [sourceId, source] of Object.entries(sources)) {
+    if (source && typeof source === "object" && source.code === true) {
+      logger2.warning(
+        `DEPRECATED: Source "${sourceId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a source package instead.`
+      );
+      hasDeprecatedCodeTrue = true;
+    }
+  }
+  const destinations = flowConfig.destinations || {};
+  for (const [destId, dest] of Object.entries(destinations)) {
+    if (dest && typeof dest === "object" && dest.code === true) {
+      logger2.warning(
+        `DEPRECATED: Destination "${destId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a destination package instead.`
+      );
+      hasDeprecatedCodeTrue = true;
+    }
+  }
+  const transformers = flowConfig.transformers || {};
+  for (const [transformerId, transformer] of Object.entries(transformers)) {
+    if (transformer && typeof transformer === "object" && transformer.code === true) {
+      logger2.warning(
+        `DEPRECATED: Transformer "${transformerId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a transformer package instead.`
+      );
+      hasDeprecatedCodeTrue = true;
+    }
+  }
+  if (hasDeprecatedCodeTrue) {
+    logger2.warning(
+      `See https://www.elbwalker.com/docs/walkeros/getting-started/flow for migration guide.`
+    );
+  }
+  return hasDeprecatedCodeTrue;
+}
 async function bundleCore(flowConfig, buildOptions, logger2, showStats = false) {
   const bundleStartTime = Date.now();
+  const hasDeprecatedFeatures = validateFlowConfig(flowConfig, logger2);
+  if (hasDeprecatedFeatures) {
+    logger2.warning("Skipping deprecated code: true entries from bundle.");
+  }
   const TEMP_DIR = buildOptions.tempDir || getTmpPath();
   if (buildOptions.cache !== false) {
     const configContent = generateCacheKeyContent(flowConfig, buildOptions);
@@ -1079,6 +1164,9 @@ function detectDestinationPackages(flowConfig) {
   const destinations = flowConfig.destinations;
   if (destinations) {
     for (const [destKey, destConfig] of Object.entries(destinations)) {
+      if (typeof destConfig === "object" && destConfig !== null && "code" in destConfig && destConfig.code === true) {
+        continue;
+      }
       if (typeof destConfig === "object" && destConfig !== null && "package" in destConfig && typeof destConfig.package === "string") {
         destinationPackages.add(destConfig.package);
       }
@@ -1091,6 +1179,9 @@ function detectSourcePackages(flowConfig) {
   const sources = flowConfig.sources;
   if (sources) {
     for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
+      if (typeof sourceConfig === "object" && sourceConfig !== null && "code" in sourceConfig && sourceConfig.code === true) {
+        continue;
+      }
       if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string") {
         sourcePackages.add(sourceConfig.package);
       }
@@ -1098,11 +1189,31 @@ function detectSourcePackages(flowConfig) {
   }
   return sourcePackages;
 }
+function detectTransformerPackages(flowConfig) {
+  const transformerPackages = /* @__PURE__ */ new Set();
+  const transformers = flowConfig.transformers;
+  if (transformers) {
+    for (const [transformerKey, transformerConfig] of Object.entries(
+      transformers
+    )) {
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "code" in transformerConfig && transformerConfig.code === true) {
+        continue;
+      }
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "package" in transformerConfig && typeof transformerConfig.package === "string") {
+        transformerPackages.add(transformerConfig.package);
+      }
+    }
+  }
+  return transformerPackages;
+}
 function detectExplicitCodeImports(flowConfig) {
   const explicitCodeImports = /* @__PURE__ */ new Map();
   const destinations = flowConfig.destinations;
   if (destinations) {
     for (const [destKey, destConfig] of Object.entries(destinations)) {
+      if (typeof destConfig === "object" && destConfig !== null && "code" in destConfig && destConfig.code === true) {
+        continue;
+      }
       if (typeof destConfig === "object" && destConfig !== null && "package" in destConfig && typeof destConfig.package === "string" && "code" in destConfig && typeof destConfig.code === "string") {
         const isAutoGenerated = destConfig.code.startsWith("_");
         if (!isAutoGenerated) {
@@ -1117,6 +1228,9 @@ function detectExplicitCodeImports(flowConfig) {
   const sources = flowConfig.sources;
   if (sources) {
     for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
+      if (typeof sourceConfig === "object" && sourceConfig !== null && "code" in sourceConfig && sourceConfig.code === true) {
+        continue;
+      }
       if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string" && "code" in sourceConfig && typeof sourceConfig.code === "string") {
         const isAutoGenerated = sourceConfig.code.startsWith("_");
         if (!isAutoGenerated) {
@@ -1128,12 +1242,35 @@ function detectExplicitCodeImports(flowConfig) {
       }
     }
   }
+  const transformers = flowConfig.transformers;
+  if (transformers) {
+    for (const [transformerKey, transformerConfig] of Object.entries(
+      transformers
+    )) {
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "code" in transformerConfig && transformerConfig.code === true) {
+        continue;
+      }
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "package" in transformerConfig && typeof transformerConfig.package === "string" && "code" in transformerConfig && 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);
+        }
+      }
+    }
+  }
   return explicitCodeImports;
 }
-function generateImportStatements(packages, destinationPackages, sourcePackages, explicitCodeImports) {
+function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, explicitCodeImports) {
   const importStatements = [];
   const examplesMappings = [];
-  const usedPackages = /* @__PURE__ */ new Set([...destinationPackages, ...sourcePackages]);
+  const usedPackages = /* @__PURE__ */ new Set([
+    ...destinationPackages,
+    ...sourcePackages,
+    ...transformerPackages
+  ]);
   for (const [packageName, packageConfig] of Object.entries(packages)) {
     const isUsedByDestOrSource = usedPackages.has(packageName);
     const hasExplicitCode = explicitCodeImports.has(packageName);
@@ -1191,11 +1328,13 @@ function generateImportStatements(packages, destinationPackages, sourcePackages,
 async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
   const destinationPackages = detectDestinationPackages(flowConfig);
   const sourcePackages = detectSourcePackages(flowConfig);
+  const transformerPackages = detectTransformerPackages(flowConfig);
   const explicitCodeImports = detectExplicitCodeImports(flowConfig);
   const { importStatements } = generateImportStatements(
     buildOptions.packages,
     destinationPackages,
     sourcePackages,
+    transformerPackages,
     explicitCodeImports
   );
   const importsCode = importStatements.join("\n");
@@ -1243,9 +1382,34 @@ function buildConfigObject(flowConfig, explicitCodeImports) {
   const flowWithProps = flowConfig;
   const sources = flowWithProps.sources || {};
   const destinations = flowWithProps.destinations || {};
-  const sourcesEntries = Object.entries(sources).map(([key, source]) => {
-    const hasExplicitCode = source.code && explicitCodeImports.has(source.package);
-    const codeVar = hasExplicitCode ? source.code : packageNameToVariable(source.package);
+  const transformers = flowWithProps.transformers || {};
+  Object.entries(sources).forEach(([name, source]) => {
+    if (source.code !== true) {
+      validateReference("Source", name, source);
+    }
+  });
+  Object.entries(destinations).forEach(([name, dest]) => {
+    if (dest.code !== true) {
+      validateReference("Destination", name, dest);
+    }
+  });
+  Object.entries(transformers).forEach(([name, transformer]) => {
+    if (transformer.code !== true) {
+      validateReference("Transformer", name, transformer);
+    }
+  });
+  const sourcesEntries = Object.entries(sources).filter(
+    ([, source]) => source.code !== true && (source.package || isInlineCode(source.code))
+  ).map(([key, source]) => {
+    if (isInlineCode(source.code)) {
+      return `    ${key}: ${generateInlineCode(source.code, source.config || {})}`;
+    }
+    let codeVar;
+    if (source.code && typeof source.code === "string" && explicitCodeImports.has(source.package)) {
+      codeVar = source.code;
+    } else {
+      codeVar = packageNameToVariable(source.package);
+    }
     const configStr = source.config ? processConfigValue(source.config) : "{}";
     const envStr = source.env ? `,
       env: ${processConfigValue(source.env)}` : "";
@@ -1254,28 +1418,64 @@ function buildConfigObject(flowConfig, explicitCodeImports) {
       config: ${configStr}${envStr}
     }`;
   });
-  const destinationsEntries = Object.entries(destinations).map(
-    ([key, dest]) => {
-      const hasExplicitCode = dest.code && explicitCodeImports.has(dest.package);
-      const codeVar = hasExplicitCode ? dest.code : packageNameToVariable(dest.package);
-      const configStr = dest.config ? processConfigValue(dest.config) : "{}";
-      const envStr = dest.env ? `,
+  const destinationsEntries = Object.entries(destinations).filter(
+    ([, dest]) => dest.code !== true && (dest.package || isInlineCode(dest.code))
+  ).map(([key, dest]) => {
+    if (isInlineCode(dest.code)) {
+      return `    ${key}: ${generateInlineDestinationCode(dest.code, dest.config || {})}`;
+    }
+    let codeVar;
+    if (dest.code && typeof dest.code === "string" && explicitCodeImports.has(dest.package)) {
+      codeVar = dest.code;
+    } else {
+      codeVar = packageNameToVariable(dest.package);
+    }
+    const configStr = dest.config ? processConfigValue(dest.config) : "{}";
+    const envStr = dest.env ? `,
       env: ${processConfigValue(dest.env)}` : "";
-      return `    ${key}: {
+    return `    ${key}: {
       code: ${codeVar},
       config: ${configStr}${envStr}
     }`;
+  });
+  const transformersEntries = Object.entries(transformers).filter(
+    ([, transformer]) => transformer.code !== true && (transformer.package || isInlineCode(transformer.code))
+  ).map(([key, transformer]) => {
+    if (isInlineCode(transformer.code)) {
+      const configWithNext2 = transformer.next ? {
+        ...transformer.config || {},
+        next: transformer.next
+      } : transformer.config || {};
+      return `    ${key}: ${generateInlineCode(transformer.code, configWithNext2)}`;
+    }
+    let codeVar;
+    if (transformer.code && typeof transformer.code === "string" && explicitCodeImports.has(transformer.package)) {
+      codeVar = transformer.code;
+    } else {
+      codeVar = packageNameToVariable(transformer.package);
     }
-  );
+    const configWithNext = transformer.next ? { ...transformer.config || {}, next: transformer.next } : transformer.config;
+    const configStr = configWithNext ? processConfigValue(configWithNext) : "{}";
+    const envStr = transformer.env ? `,
+      env: ${processConfigValue(transformer.env)}` : "";
+    return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}
+    }`;
+  });
   const collectorStr = flowWithProps.collector ? `,
   ...${processConfigValue(flowWithProps.collector)}` : "";
+  const transformersStr = transformersEntries.length > 0 ? `,
+  transformers: {
+${transformersEntries.join(",\n")}
+  }` : "";
   return `{
   sources: {
 ${sourcesEntries.join(",\n")}
   },
   destinations: {
 ${destinationsEntries.join(",\n")}
-  }${collectorStr}
+  }${transformersStr}${collectorStr}
 }`;
 }
 function processConfigValue(value) {