@motiadev/core 0.0.19 → 0.0.21

package/dist/src/printer.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Printer = void 0;
+const colors_1 = __importDefault(require("colors"));
+const path_1 = __importDefault(require("path"));
+const guards_1 = require("./guards");
+const stepTag = colors_1.default.bold(colors_1.default.magenta('Step'));
+const flowTag = colors_1.default.bold(colors_1.default.blue('Flow'));
+const created = colors_1.default.green('➜ [CREATED]');
+const updated = colors_1.default.yellow('➜ [UPDATED]');
+const removed = colors_1.default.red('➜ [REMOVED]');
+const invalidEmit = colors_1.default.red('➜ [INVALID EMIT]');
+const error = colors_1.default.red('[ERROR]');
+class Printer {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    printInvalidEmit(step, emit) {
+        console.log(`${invalidEmit} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} tried to emit an event not defined in the step config: ${colors_1.default.yellow(emit)}`);
+    }
+    printStepCreated(step) {
+        console.log(`${created} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} created`);
+    }
+    printStepUpdated(step) {
+        console.log(`${updated} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} updated`);
+    }
+    printStepRemoved(step) {
+        console.log(`${removed} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} removed`);
+    }
+    printFlowCreated(flowName) {
+        console.log(`${created} ${flowTag} ${colors_1.default.bold(colors_1.default.cyan(flowName))} created`);
+    }
+    printFlowUpdated(flowName) {
+        console.log(`${updated} ${flowTag} ${colors_1.default.bold(colors_1.default.cyan(flowName))} updated`);
+    }
+    printFlowRemoved(flowName) {
+        console.log(`${removed} ${flowTag} ${colors_1.default.bold(colors_1.default.cyan(flowName))} removed`);
+    }
+    printValidationError(stepPath, validationError) {
+        const relativePath = this.getRelativePath(stepPath);
+        console.log(`${error} ${colors_1.default.bold(colors_1.default.cyan(relativePath))}`);
+        validationError.errors?.forEach((error) => {
+            if (error.path) {
+                console.log(`${colors_1.default.red('│')} ${colors_1.default.yellow(`✖ ${error.path}`)}: ${error.message}`);
+            }
+            else {
+                console.log(`${colors_1.default.red('│')} ${colors_1.default.yellow('✖')} ${error.message}`);
+            }
+        });
+        console.log(`${colors_1.default.red('└─')} ${colors_1.default.red(validationError.error)}  `);
+    }
+    getRelativePath(filePath) {
+        return path_1.default.relative(this.baseDir, filePath);
+    }
+    getStepType(step) {
+        if ((0, guards_1.isApiStep)(step))
+            return colors_1.default.gray('(API)');
+        if ((0, guards_1.isEventStep)(step))
+            return colors_1.default.gray('(Event)');
+        if ((0, guards_1.isCronStep)(step))
+            return colors_1.default.gray('(Cron)');
+        if ((0, guards_1.isNoopStep)(step))
+            return colors_1.default.gray('(Noop)');
+        return colors_1.default.gray('(Unknown)');
+    }
+    getStepPath(step) {
+        const stepPath = this.getRelativePath(step.filePath);
+        return colors_1.default.bold(colors_1.default.cyan(stepPath));
+    }
+}
+exports.Printer = Printer;

package/dist/src/python/logger.py

@@ -3,11 +3,11 @@ from typing import Any, Dict, Optional
 from rpc import RpcSender
 
 class Logger:
-    def __init__(self, trace_id: str, flows: list[str], file_path: str, sender: RpcSender):
+    def __init__(self, trace_id: str, flows: list[str], file_path: str, rpc: RpcSender):
         self.trace_id = trace_id
         self.flows = flows
         self.file_name = file_path.split('/')[-1]
-        self.sender = sender
+        self.rpc = rpc
 
     def _log(self, level: str, message: str, args: Optional[Dict[str, Any]] = None) -> None:
         log_entry = {
@@ -27,7 +27,7 @@ class Logger:
                 args = {"data": args}
             log_entry.update(args)
 
-        self.sender.send_no_wait('log', log_entry)
+        self.rpc.send_no_wait('log', log_entry)
 
     def info(self, message: str, args: Optional[Any] = None) -> None:
         self._log("info", message, args)

package/dist/src/python/python-runner.py

@@ -2,6 +2,7 @@ import sys
 import json
 import importlib.util
 import traceback
+import asyncio
 import os
 from logger import Logger
 from rpc import RpcSender
@@ -19,18 +20,18 @@ def parse_args(arg: str) -> Any:
         return arg
 
 class Context:
-    def __init__(self, args: Any, file_name: str):
+    def __init__(self, args: Any, rpc: RpcSender, file_name: str):
         self.trace_id = args.traceId
         self.flows = args.flows
         self.file_name = file_name
-        self.sender = RpcSender()
-        self.state = RpcStateManager(self.sender)
-        self.logger = Logger(self.trace_id, self.flows, self.file_name, self.sender)
+        self.rpc = rpc
+        self.state = RpcStateManager(rpc)
+        self.logger = Logger(self.trace_id, self.flows, self.file_name, rpc)
 
     async def emit(self, event: Any):
-        await self.sender.send('emit', event)
+        return await self.rpc.send('emit', event)
 
-async def run_python_module(file_path: str, args: Any) -> None:
+async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
     try:
         # Construct path relative to steps directory
         flows_dir = os.path.join(os.getcwd(), 'steps')
@@ -48,16 +49,16 @@ async def run_python_module(file_path: str, args: Any) -> None:
         if not hasattr(module, 'handler'):
             raise AttributeError(f"Function 'handler' not found in module {module_path}")
 
-        context = Context(args, file_path)
-        context.sender.init()
-        
+        context = Context(args, rpc, file_path)
+
         await module.handler(args.data, context)
-        
-        # exit with 0 to indicate success
-        sys.exit(0)
-    except Exception as error:
-        print('Error running Python module:', file=sys.stderr)
 
+        rpc.close()
+
+        # We need this to close the process
+        rpc.send_no_wait('close', None)
+    except Exception as error:
+        print(f'Error running Python module: {error}', file=sys.stderr)
         traceback.print_exc(file=sys.stderr)
         sys.exit(1)
 
@@ -69,5 +70,9 @@ if __name__ == "__main__":
     file_path = sys.argv[1]
     arg = sys.argv[2] if len(sys.argv) > 2 else None
 
-    import asyncio
-    asyncio.run(run_python_module(file_path, parse_args(arg)))
+    rpc = RpcSender()
+    loop = asyncio.get_event_loop()
+    # Create and gather tasks
+    tasks = asyncio.gather(rpc.init(), run_python_module(file_path, rpc, parse_args(arg)))
+    # Run until tasks complete
+    loop.run_until_complete(tasks)

package/dist/src/python/rpc.py

@@ -10,6 +10,7 @@ NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
 
 class RpcSender:
     def __init__(self):
+        self.executing = True
         self.pending_requests: Dict[str, Tuple[asyncio.Future, str, Any]] = {}
 
     def send_no_wait(self, method: str, args: Any) -> None:
@@ -23,10 +24,10 @@ class RpcSender:
         # send message
         os.write(NODEIPCFD, bytesMessage)
 
-    async def send(self, method: str, args: Any) -> Any:
+    async def send(self, method: str, args: Any) -> asyncio.Future[Any]:
         future = asyncio.Future()
         request_id = str(uuid.uuid4())
-        self.pending_requests[request_id] = (future, method, args)
+        self.pending_requests[request_id] = future
 
         request = {
             'type': 'rpc_request',
@@ -39,16 +40,17 @@ class RpcSender:
         # send message
         os.write(NODEIPCFD, bytesMessage)
 
-        return future
+        return await future
 
-    def init(self):
+    async def init(self):
         def on_message(msg: Dict[str, Any]):
             if msg.get('type') == 'rpc_response':
                 request_id = msg['id']
 
                 if request_id in self.pending_requests:
-                    future, _, _ = self.pending_requests[request_id]
-
+                    future = self.pending_requests[request_id]
+                    del self.pending_requests[request_id]
+                    
                     if msg.get('error'):
                         future.set_exception(msg['error'])
                     elif msg.get('result'):
@@ -56,15 +58,16 @@ class RpcSender:
                     else:
                         # It's a void response
                         future.set_result(None)
-
-                    del self.pending_requests[request_id]
-
+            
         # Read messages from Node IPC file descriptor
-        async def read_messages():
-            while True:
-                # Read message from pipe
-                message = os.read(NODEIPCFD, 4096).decode('utf-8')
+        while self.executing:
+            # Use asyncio to read from fd without blocking
+            try:
+                message = await asyncio.get_event_loop().run_in_executor(
+                    None, lambda: os.read(NODEIPCFD, 4096).decode('utf-8')
+                )
                 if not message:
+                    await asyncio.sleep(0.01)  # Add small delay to prevent busy-waiting
                     continue
                     
                 # Parse messages (may be multiple due to buffering)
@@ -75,6 +78,14 @@ class RpcSender:
                             on_message(msg)
                         except json.JSONDecodeError:
                             pass
+            except Exception as e:
+                print(f"Error reading from IPC: {e}", file=sys.stderr)
+                await asyncio.sleep(0.01)
 
-        # Start message reading loop
-        asyncio.create_task(read_messages())
+    def close(self) -> None:
+        self.executing = False
+        outstanding_requests = list(self.pending_requests.values())
+        
+        if len(outstanding_requests) > 0:
+            print("Process ended while there are some promises outstanding", file=sys.stderr)
+            sys.exit(1)

package/dist/src/python/rpc_state_manager.py

@@ -1,18 +1,19 @@
 from typing import Any
-
+import asyncio
+from rpc import RpcSender
 
 class RpcStateManager:
-    def __init__(self, sender):
-        self.sender = sender
+    def __init__(self, rpc: RpcSender):
+        self.rpc = rpc
 
-    async def get(self, trace_id: str, key: str) -> Any:
-        return await self.sender.send('state.get', {'traceId': trace_id, 'key': key})
+    async def get(self, trace_id: str, key: str) -> asyncio.Future[Any]:
+        return await self.rpc.send('state.get', {'traceId': trace_id, 'key': key})
 
-    async def set(self, trace_id: str, key: str, value: Any) -> None:
-        await self.sender.send('state.set', {'traceId': trace_id, 'key': key, 'value': value})
+    async def set(self, trace_id: str, key: str, value: Any) -> asyncio.Future[None]:
+        return await self.rpc.send('state.set', {'traceId': trace_id, 'key': key, 'value': value})
 
-    async def delete(self, trace_id: str, key: str) -> None:
-        await self.sender.send('state.delete', {'traceId': trace_id, 'key': key})
+    async def delete(self, trace_id: str, key: str) -> asyncio.Future[None]:
+        return await self.rpc.send('state.delete', {'traceId': trace_id, 'key': key})
 
-    async def clear(self, trace_id: str) -> None:
-        await self.sender.send('state.clear', {'traceId': trace_id})
+    async def clear(self, trace_id: str) -> asyncio.Future[None]:
+        return await self.rpc.send('state.clear', {'traceId': trace_id})

package/dist/src/ruby/get_config.rb

@@ -19,28 +19,18 @@ end
 
 def extract_config(file_path)
   begin
-    # Remove previous Config class if it exists
-    Object.send(:remove_const, :Config) if Object.const_defined?(:Config)
-    
-    # Create a new binding for evaluation
-    evaluation_binding = binding
-    
-    # Load and evaluate the file content in our binding
-    file_content = File.read(file_path)
-    evaluation_binding.eval(file_content)
-    
-    # Get the config variable from our binding
-    config = evaluation_binding.eval('config')
-    
-    # Convert config instance to hash with symbol keys
-    {
-      type: config.type,
-      name: config.name,
-      subscribes: config.subscribes,
-      emits: config.emits,
-      input: config.input,
-      flows: config.flows
-    }
+    unless File.exist?(file_path)
+      raise LoadError, "Could not load module from #{file_path}"
+    end
+
+    # Load the file in a clean context
+    load file_path
+
+    unless defined?(config)
+      raise NameError, "Function 'config' not found in module #{file_path}"
+    end
+
+    config()
   rescue NameError => e
     raise "Error accessing config: #{e.message}"
   rescue => e

package/dist/src/ruby/logger.rb

@@ -2,39 +2,46 @@ require 'json'
 require 'time'
 
 class CustomLogger
-  def initialize(trace_id, flows, file_path)
+  def initialize(trace_id, flows, file_path, sender)
     @trace_id = trace_id
     @flows = flows
-    @file_name = File.basename(file_path)
+    @file_name = file_path.split('/').last
+    @sender = sender
   end
 
   def log(level, message, args = nil)
-    # Ensure message is not nested JSON or a stringified JSON object
+    # Handle message formatting consistently with Python/Node
     if message.is_a?(String) && message.strip.start_with?('{', '[')
       begin
-        message = JSON.parse(message) # Parse if valid JSON
+        message = JSON.parse(message)
       rescue JSON::ParserError
-        # Leave message as is if it's not valid JSON
+        # Leave message as is if not valid JSON
       end
     end
 
-    # Construct the base log entry
+    # Construct the log entry to match Python/Node format
     log_entry = {
+      level: level,
+      time: (Time.now.to_f * 1000).to_i,  # Milliseconds since epoch to match Node
+      traceId: @trace_id,
+      flows: @flows,
+      file: @file_name,
       msg: message
     }
 
-    # Merge additional arguments if provided
+    # Handle additional args consistently with Python/Node
     if args
-      args = case args
-             when OpenStruct then args.to_h
-             when Hash then args
-             else { data: args }
-             end
-      log_entry.merge!(args)
+      case args
+      when OpenStruct
+        log_entry.merge!(args.to_h)
+      when Hash
+        log_entry.merge!(args)
+      else
+        log_entry[:data] = args
+      end
     end
 
-    # Generate JSON output
-    puts JSON.dump(log_entry)
+    @sender.send_no_wait('log', log_entry)
   end
 
   def info(message, args = nil)
@@ -52,4 +59,4 @@ class CustomLogger
   def warn(message, args = nil)
     log('warn', message, args)
   end
-end
+end

package/dist/src/ruby/rpc.rb

@@ -0,0 +1,123 @@
+require 'securerandom'
+require 'json'
+require 'thread'
+
+# Get the file descriptor from ENV
+NODE_CHANNEL_FD = ENV['NODE_CHANNEL_FD'].to_i
+
+class RpcSender
+  def initialize
+    @closed = false
+    @writer = IO.new(NODE_CHANNEL_FD, 'w')
+    @reader = IO.new(NODE_CHANNEL_FD, 'r')
+    @pending_requests = {}
+    @mutex = Mutex.new
+  end
+
+  def send(method, args)
+    return nil if @closed
+
+    id = SecureRandom.uuid
+    promise = Queue.new
+    
+    @mutex.synchronize do
+      @pending_requests[id] = promise
+    end
+
+    data = { type: 'rpc_request', id: id, method: method, args: args }
+    message = (JSON.dump(data) + "\n").encode('utf-8')
+
+    @writer.write(message)
+    @writer.flush
+
+    result = promise.pop
+    raise result if result.is_a?(StandardError)
+    result
+  end
+
+  def send_no_wait(method, args)
+    return if @closed
+
+    data = { type: 'rpc_request', method: method, args: args }
+    message = (JSON.dump(data) + "\n").encode('utf-8')
+
+    @writer.write(message)
+    @writer.flush
+  rescue IOError, Errno::EBADF
+    # Ignore errors during shutdown
+  end
+
+  def init
+    @background_thread = Thread.new do
+      until @closed
+        begin
+          line = @reader.gets
+          if line
+            msg = JSON.parse(line)
+            handle_response(msg) if msg['type'] == 'rpc_response'
+          end
+        rescue IOError, Errno::EBADF
+          break if @closed
+        rescue => e
+          puts "Error in RPC thread: #{e.message}"
+        end
+      end
+    end
+    
+    @background_thread.abort_on_exception = true
+  end
+
+  def handle_response(msg)
+    id = msg['id']
+    return unless id
+
+    @mutex.synchronize do
+      if promise = @pending_requests.delete(id)
+        if msg['error']
+          promise.push(StandardError.new(msg['error']))
+        else
+          promise.push(msg['result'])
+        end
+      end
+    end
+  end
+
+  def close
+    return if @closed
+    @closed = true
+
+    # Send final close message
+    begin
+      send_no_wait('close', nil)
+    rescue
+      # Ignore errors during shutdown
+    end
+
+    # Clean up background thread
+    if @background_thread
+      @background_thread.kill rescue nil
+      @background_thread.join(1) rescue nil
+    end
+
+    # Check for pending requests
+    @mutex.synchronize do
+      if @pending_requests.any?
+        puts 'Process ended while there are some promises outstanding'
+        exit(1)
+      end
+    end
+
+    # Close file descriptors
+    begin
+      @writer.close unless @writer.closed?
+    rescue
+      # Ignore errors during shutdown
+    end
+
+    begin
+      @reader.close unless @reader.closed?
+    rescue
+      # Ignore errors during shutdown
+    end
+  end
+end

package/dist/src/ruby/rpc_state_manager.rb

@@ -0,0 +1,25 @@
+class RpcStateManager
+  def initialize(sender)
+    @sender = sender
+  end
+
+  def get(trace_id, key)
+    # Return promise to match Python/Node behavior
+    @sender.send('state.get', { traceId: trace_id, key: key })
+  end
+
+  def set(trace_id, key, value)
+    # Return promise to match Python/Node behavior
+    @sender.send('state.set', { traceId: trace_id, key: key, value: value })
+  end
+
+  def delete(trace_id, key)
+    # Return promise to match Python/Node behavior
+    @sender.send('state.delete', { traceId: trace_id, key: key })
+  end
+
+  def clear(trace_id)
+    # Return promise to match Python/Node behavior
+    @sender.send('state.clear', { traceId: trace_id })
+  end
+end

package/dist/src/ruby/ruby_runner.rb

@@ -3,9 +3,9 @@ require 'io/console'
 require 'ostruct'
 require 'pathname'
 require_relative 'logger'
-require_relative 'state_adapter'
+require_relative 'rpc'
+require_relative 'rpc_state_manager'
 
-# Parse arguments as JSON or fallback to raw string
 def parse_args(arg)
   begin
     JSON.parse(arg, object_class: OpenStruct)
@@ -15,51 +15,61 @@ def parse_args(arg)
   end
 end
 
-# Get the file descriptor from ENV
-NODE_CHANNEL_FD = ENV['NODE_CHANNEL_FD'].to_i
-
-# Context class for managing the execution environment
 class Context
   attr_reader :trace_id, :flows, :file_name, :state, :logger
 
-  # Emit a message to the parent process via Node IPC
-  def emit(text)
-    message = (JSON.dump(text) + "\n").encode('utf-8')
-    IO.new(NODE_CHANNEL_FD, 'w').write(message)
+  def emit(event)
+    # Add type field if not present to match Node.js/Python behavior
+    event = { type: event[:type] || event['type'], data: event[:data] || event['data'] } unless event.is_a?(String)
+    promise = @rpc.send('emit', event)
+    promise  # Return promise to maintain async pattern
   end
 
-  def initialize(args, file_name)
+  def initialize(rpc, args, file_path)
+    @rpc = rpc
     @trace_id = args.traceId
     @flows = args.flows
-    @file_name = file_name
-    @state = create_internal_state_manager(state_manager_url: args[:stateConfig]&.dig(:stateManagerUrl))
-    @logger = CustomLogger.new(@trace_id, @flows, @file_name)
+    @file_name = file_path.split('/').last  # Consistent with Python/Node
+    @state = RpcStateManager.new(rpc)
+    @logger = CustomLogger.new(@trace_id, @flows, @file_name, @rpc)
   end
 end
 
-# Dynamically load and execute a Ruby script
 def run_ruby_module(file_path, args)
-  unless File.exist?(file_path)
-    raise LoadError, "Could not load module from #{file_path}"
-  end
+  rpc = nil
+  begin
+    unless File.exist?(file_path)
+      raise LoadError, "Could not load module from #{file_path}"
+    end
 
-  # Load the file dynamically
-  load file_path
+    # Load the file in a clean context
+    load file_path
 
-  unless defined?(executor)
-    raise NameError, "Function 'executor' not found in module #{file_path}"
-  end
+    unless defined?(handler)
+      raise NameError, "Function 'handler' not found in module #{file_path}"
+    end
+
+    rpc = RpcSender.new
+    context = Context.new(rpc, args, file_path)
+    rpc.init
 
-  context = Context.new(args, file_path)
+    # Call handler and wait for any promises
+    result = handler(args.data, context)
+    
+    # If handler returns a promise-like object, wait for it
+    if result.respond_to?(:value)
+      result.value
+    end
 
-  executor(args.data, context)
-rescue => e
-  $stderr.puts "Error running Ruby module: #{e.message}"
-  $stderr.puts e.backtrace
-  exit 1
+  rescue => e
+    $stderr.puts "Error running Ruby module: #{e.message}"
+    $stderr.puts e.backtrace
+    raise
+  ensure
+    rpc&.close if rpc
+  end
 end
 
-# Entry point
 if __FILE__ == $PROGRAM_NAME
   if ARGV.length < 1
     $stderr.puts 'Usage: ruby ruby-runner.rb <file-path> <arg>'
@@ -72,9 +82,10 @@ if __FILE__ == $PROGRAM_NAME
   begin
     parsed_args = parse_args(arg)
     run_ruby_module(file_path, parsed_args)
+    exit 0
   rescue => e
     $stderr.puts "Error: #{e.message}"
     $stderr.puts e.backtrace
     exit 1
   end
-end
+end