@goplasmatic/dataflow-wasm 2.0.4 → 2.0.14

package/README.md

@@ -16,9 +16,10 @@ WebAssembly bindings for [dataflow-rs](https://github.com/GoPlasmatic/dataflow-r
 ## Features
 
 - **Browser Execution** - Run dataflow-rs workflows directly in the browser
-- **Full Feature Parity** - Same workflow engine as the native Rust version
+- **Full Feature Parity** - Same workflow engine as the native Rust version including all built-in functions
+- **Built-in Functions** - parse, map, validation, publish
 - **TypeScript Support** - Full type definitions included
-- **Execution Tracing** - Debug workflows with step-by-step execution traces
+- **Execution Tracing** - Debug workflows with step-by-step execution traces and message snapshots
 
 ## Installation
 
@@ -40,6 +41,15 @@ const workflows = [
     id: 'my-workflow',
     name: 'My Workflow',
     tasks: [
+      {
+        // Parse the raw payload string into data
+        id: 'parse-payload',
+        name: 'Parse Payload',
+        function: {
+          name: 'parse',
+          input: {}
+        }
+      },
       {
         id: 'task-1',
         name: 'Transform Data',
@@ -57,12 +67,13 @@ const workflows = [
 ];
 
 // Create engine
-const engine = new WasmEngine(workflows);
+const engine = new WasmEngine(JSON.stringify(workflows));
 
-// Process a message
-const message = { data: { input: 'hello' }, metadata: {} };
-const result = await engine.process(message);
-console.log(result); // { data: { input: 'hello', output: 'hello' }, ... }
+// Process a payload (raw string - parsed by the parse plugin)
+const payload = '{"input": "hello"}';
+const result = await engine.process(payload);
+const parsed = JSON.parse(result);
+console.log(parsed.context.data); // { input: 'hello', output: 'hello' }
 ```
 
 ## API
@@ -71,44 +82,66 @@ console.log(result); // { data: { input: 'hello', output: 'hello' }, ... }
 
 ```typescript
 class WasmEngine {
-  constructor(workflows: Workflow[]);
+  // Create engine from JSON string of workflow definitions
+  constructor(workflows_json: string);
 
-  // Process a message through all workflows
-  process(message: Message): Promise<Message>;
+  // Process a raw payload string through all workflows
+  // The payload is stored as-is and should be parsed by the parse plugin
+  process(payload: string): Promise<string>;
 
   // Process with execution trace for debugging
-  processWithTrace(message: Message): Promise<ExecutionTrace>;
+  process_with_trace(payload: string): Promise<string>;
+
+  // Get number of registered workflows
+  workflow_count(): number;
+
+  // Get list of workflow IDs as JSON array string
+  workflow_ids(): string;
 }
 ```
 
-### Types
+### Standalone Function
 
 ```typescript
-interface Workflow {
-  id: string;
-  name: string;
-  condition?: JsonLogicValue;
-  tasks: Task[];
-}
+// Process a payload through a one-off engine (convenience function)
+// Use WasmEngine class for better performance when processing multiple payloads
+function process_message(workflows_json: string, payload: string): Promise<string>;
+```
 
-interface Task {
-  id: string;
-  name: string;
-  condition?: JsonLogicValue;
-  function: FunctionConfig;
-}
+### Payload Handling
 
-interface Message {
-  data: object;
-  metadata: object;
-  payload?: object;
-  temp_data?: object;
+The payload is stored as a **raw string** and is not automatically parsed. Use the `parse` plugin as the first task in your workflow to parse JSON/XML payloads into `context.data`:
+
+```typescript
+{
+  id: 'parse-payload',
+  name: 'Parse Payload',
+  function: {
+    name: 'parse',
+    input: {
+      source: 'payload',      // default
+      target: 'data',         // default
+      format: 'json'          // default, or 'xml'
+    }
+  }
 }
+```
 
-interface ExecutionTrace {
-  steps: ExecutionStep[];
-  initial_message: Message;
-  final_message: Message;
+### Message Structure
+
+The processed message has the following structure:
+
+```typescript
+interface Message {
+  id: string;
+  payload: string;              // Raw payload string
+  context: {
+    data: object;               // Parsed data (populated by parse plugin)
+    metadata: object;           // Workflow metadata
+    temp_data: object;          // Temporary data during processing
+  };
+  audit_trail: AuditEntry[];    // Execution history
+  errors: ErrorInfo[];          // Any errors that occurred
 }
 ```
 

package/dataflow_wasm.d.ts

@@ -32,44 +32,47 @@ export class WasmEngine {
      * Process a payload through the engine's workflows.
      *
      * This is an async operation that returns a Promise.
+     * The payload is stored as a raw string and should be parsed by a parse plugin
+     * in the workflow if JSON parsing is needed.
      *
      * # Arguments
-     * * `payload_json` - JSON string of the payload to process
+     * * `payload` - Raw string payload to process (not parsed by the engine)
      *
      * # Returns
      * A Promise that resolves to the processed message as a JSON string
      *
      * # Example
      * ```javascript
-     * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+     * const payload = '{"name": "John", "email": "john@example.com"}';
      * const result = await engine.process(payload);
      * const processed = JSON.parse(result);
      * console.log(processed.context.data);
      * ```
      */
-    process(payload_json: string): Promise<any>;
+    process(payload: string): Promise<any>;
     /**
      * Process a payload with step-by-step execution tracing.
      *
      * This is an async operation that returns a Promise with the execution trace.
      * The trace contains message snapshots after each step, including which
      * workflows/tasks were executed or skipped.
+     * The payload is stored as a raw string and should be parsed by a parse plugin.
      *
      * # Arguments
-     * * `payload_json` - JSON string of the payload to process
+     * * `payload` - Raw string payload to process (not parsed by the engine)
      *
      * # Returns
      * A Promise that resolves to the execution trace as a JSON string
      *
      * # Example
      * ```javascript
-     * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+     * const payload = '{"name": "John", "email": "john@example.com"}';
      * const trace = await engine.process_with_trace(payload);
      * const traceData = JSON.parse(trace);
      * console.log(traceData.steps); // Array of execution steps
      * ```
      */
-    process_with_trace(payload_json: string): Promise<any>;
+    process_with_trace(payload: string): Promise<any>;
     /**
      * Get the number of workflows registered in the engine.
      */
@@ -83,24 +86,6 @@ export class WasmEngine {
     workflow_ids(): string;
 }
 
-/**
- * Create a message JSON string from data and metadata.
- *
- * # Arguments
- * * `data` - JSON string containing the message data (goes to context.data)
- * * `metadata` - JSON string containing the message metadata (goes to context.metadata)
- *
- * # Returns
- * JSON string representing the complete message, or an error message
- *
- * # Example
- * ```javascript
- * const message = create_message('{"name": "John"}', '{"type": "user"}');
- * const result = await engine.process(message);
- * ```
- */
-export function create_message(data: string, metadata: string): string;
-
 /**
  * Initialize the WASM module.
  *
@@ -114,29 +99,29 @@ export function init(): void;
  *
  * Creates an engine with the given workflows and processes a single payload.
  * Use WasmEngine class for better performance when processing multiple payloads.
+ * The payload is stored as a raw string and should be parsed by a parse plugin.
  *
  * # Arguments
  * * `workflows_json` - JSON string containing an array of workflow definitions
- * * `payload_json` - JSON string of the payload to process
+ * * `payload` - Raw string payload to process (not parsed by the engine)
  *
  * # Returns
  * A Promise that resolves to the processed message as a JSON string
  *
  * # Example
  * ```javascript
- * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+ * const payload = '{"name": "John", "email": "john@example.com"}';
  * const result = await process_message(workflowsJson, payload);
  * console.log(JSON.parse(result));
  * ```
  */
-export function process_message(workflows_json: string, payload_json: string): Promise<any>;
+export function process_message(workflows_json: string, payload: string): Promise<any>;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_wasmengine_free: (a: number, b: number) => void;
-    readonly create_message: (a: number, b: number, c: number, d: number) => [number, number, number, number];
     readonly init: () => void;
     readonly process_message: (a: number, b: number, c: number, d: number) => any;
     readonly wasmengine_new: (a: number, b: number) => [number, number, number];
@@ -144,9 +129,9 @@ export interface InitOutput {
     readonly wasmengine_process_with_trace: (a: number, b: number, c: number) => any;
     readonly wasmengine_workflow_count: (a: number) => number;
     readonly wasmengine_workflow_ids: (a: number) => [number, number];
-    readonly wasm_bindgen__closure__destroy__h6c21e3ac8818b8da: (a: number, b: number) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__h6a4d7bdc6e47fe09: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__ha914c30c59f13cef: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__closure__destroy__h986238a7f20e7074: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h019b9b7d5351973d: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hd0a577b47a103e40: (a: number, b: number, c: any) => void;
     readonly __wbindgen_exn_store: (a: number) => void;
     readonly __externref_table_alloc: () => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;

package/dataflow_wasm.js

@@ -50,25 +50,27 @@ export class WasmEngine {
      * Process a payload through the engine's workflows.
      *
      * This is an async operation that returns a Promise.
+     * The payload is stored as a raw string and should be parsed by a parse plugin
+     * in the workflow if JSON parsing is needed.
      *
      * # Arguments
-     * * `payload_json` - JSON string of the payload to process
+     * * `payload` - Raw string payload to process (not parsed by the engine)
      *
      * # Returns
      * A Promise that resolves to the processed message as a JSON string
      *
      * # Example
      * ```javascript
-     * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+     * const payload = '{"name": "John", "email": "john@example.com"}';
      * const result = await engine.process(payload);
      * const processed = JSON.parse(result);
      * console.log(processed.context.data);
      * ```
-     * @param {string} payload_json
+     * @param {string} payload
      * @returns {Promise<any>}
      */
-    process(payload_json) {
-        const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    process(payload) {
+        const ptr0 = passStringToWasm0(payload, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.wasmengine_process(this.__wbg_ptr, ptr0, len0);
         return ret;
@@ -79,25 +81,26 @@ export class WasmEngine {
      * This is an async operation that returns a Promise with the execution trace.
      * The trace contains message snapshots after each step, including which
      * workflows/tasks were executed or skipped.
+     * The payload is stored as a raw string and should be parsed by a parse plugin.
      *
      * # Arguments
-     * * `payload_json` - JSON string of the payload to process
+     * * `payload` - Raw string payload to process (not parsed by the engine)
      *
      * # Returns
      * A Promise that resolves to the execution trace as a JSON string
      *
      * # Example
      * ```javascript
-     * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+     * const payload = '{"name": "John", "email": "john@example.com"}';
      * const trace = await engine.process_with_trace(payload);
      * const traceData = JSON.parse(trace);
      * console.log(traceData.steps); // Array of execution steps
      * ```
-     * @param {string} payload_json
+     * @param {string} payload
      * @returns {Promise<any>}
      */
-    process_with_trace(payload_json) {
-        const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    process_with_trace(payload) {
+        const ptr0 = passStringToWasm0(payload, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.wasmengine_process_with_trace(this.__wbg_ptr, ptr0, len0);
         return ret;
@@ -132,48 +135,6 @@ export class WasmEngine {
 }
 if (Symbol.dispose) WasmEngine.prototype[Symbol.dispose] = WasmEngine.prototype.free;
 
-/**
- * Create a message JSON string from data and metadata.
- *
- * # Arguments
- * * `data` - JSON string containing the message data (goes to context.data)
- * * `metadata` - JSON string containing the message metadata (goes to context.metadata)
- *
- * # Returns
- * JSON string representing the complete message, or an error message
- *
- * # Example
- * ```javascript
- * const message = create_message('{"name": "John"}', '{"type": "user"}');
- * const result = await engine.process(message);
- * ```
- * @param {string} data
- * @param {string} metadata
- * @returns {string}
- */
-export function create_message(data, metadata) {
-    let deferred4_0;
-    let deferred4_1;
-    try {
-        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(metadata, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.create_message(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
-            ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
-    } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
-    }
-}
-
 /**
  * Initialize the WASM module.
  *
@@ -189,28 +150,29 @@ export function init() {
  *
  * Creates an engine with the given workflows and processes a single payload.
  * Use WasmEngine class for better performance when processing multiple payloads.
+ * The payload is stored as a raw string and should be parsed by a parse plugin.
  *
  * # Arguments
  * * `workflows_json` - JSON string containing an array of workflow definitions
- * * `payload_json` - JSON string of the payload to process
+ * * `payload` - Raw string payload to process (not parsed by the engine)
  *
  * # Returns
  * A Promise that resolves to the processed message as a JSON string
  *
  * # Example
  * ```javascript
- * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+ * const payload = '{"name": "John", "email": "john@example.com"}';
  * const result = await process_message(workflowsJson, payload);
  * console.log(JSON.parse(result));
  * ```
  * @param {string} workflows_json
- * @param {string} payload_json
+ * @param {string} payload
  * @returns {Promise<any>}
  */
-export function process_message(workflows_json, payload_json) {
+export function process_message(workflows_json, payload) {
     const ptr0 = passStringToWasm0(workflows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ptr1 = passStringToWasm0(payload, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     const ret = wasm.process_message(ptr0, len0, ptr1, len1);
     return ret;
@@ -274,7 +236,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h6a4d7bdc6e47fe09(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h019b9b7d5351973d(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -328,8 +290,8 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 55, function: Function { arguments: [Externref], shim_idx: 61, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h6c21e3ac8818b8da, wasm_bindgen__convert__closures_____invoke__ha914c30c59f13cef);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 49, function: Function { arguments: [Externref], shim_idx: 50, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h986238a7f20e7074, wasm_bindgen__convert__closures_____invoke__hd0a577b47a103e40);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
@@ -353,12 +315,12 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__ha914c30c59f13cef(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__ha914c30c59f13cef(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__hd0a577b47a103e40(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hd0a577b47a103e40(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h6a4d7bdc6e47fe09(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h6a4d7bdc6e47fe09(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h019b9b7d5351973d(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h019b9b7d5351973d(arg0, arg1, arg2, arg3);
 }
 
 const WasmEngineFinalization = (typeof FinalizationRegistry === 'undefined')

package/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "author": "Plasmatic Engineering <shankar@goplasmatic.io>",
   "description": "WebAssembly bindings for dataflow-rs workflow engine",
-  "version": "2.0.4",
+  "version": "2.0.14",
   "license": "Apache-2.0",
   "homepage": "https://github.com/GoPlasmatic/dataflow-rs",
   "repository": {
@@ -25,12 +25,5 @@
   "sideEffects": [
     "./snippets/*"
   ],
-  "keywords": [
-    "workflow",
-    "engine",
-    "wasm",
-    "webassembly",
-    "dataflow",
-    "rust"
-  ]
+  "keywords": ["workflow", "engine", "wasm", "webassembly", "dataflow", "rust"]
 }