hatchet-sdk 0.0.0 → 0.1.0.pre.alpha

data/lib/hatchet-sdk.rb

@@ -1,15 +1,86 @@
 # frozen_string_literal: true
+# typed: strict
 
 require_relative "hatchet/version"
+require_relative "hatchet/config"
+require_relative "hatchet/clients"
+require_relative "hatchet/features/events"
+require_relative "hatchet/features/runs"
 
+# Ruby SDK for Hatchet workflow engine
+#
+# @see https://docs.hatchet.run for Hatchet documentation
 module Hatchet
+  # Base error class for all Hatchet-related errors
   class Error < StandardError; end
 
+  # The main client for interacting with Hatchet services.
+  #
+  # @example Basic usage with API token
+  #   hatchet = Hatchet::Client.new()
+  #
+  # @example With custom configuration
+  #   hatchet = Hatchet::Client.new(
+  #     token: "your-jwt-token",
+  #     namespace: "production"
+  #   )
   class Client
-    attr_reader :api_key
+    # @return [Config] The configuration object used by this client
+    attr_reader :config
 
-    def initialize(api_key)
-      @api_key = api_key
+    # Initialize a new Hatchet client with the given configuration options.
+    #
+    # @param options [Hash] Configuration options for the client
+    # @option options [String] :token The JWT token for authentication (required)
+    # @option options [String] :tenant_id Override tenant ID (extracted from JWT token 'sub' field if not provided)
+    # @option options [String] :host_port gRPC server host and port (default: "localhost:7070")
+    # @option options [String] :server_url Server URL for HTTP requests (default: "https://app.dev.hatchet-tools.com")
+    # @option options [String] :namespace Namespace prefix for resource names (default: "")
+    # @option options [Logger] :logger Custom logger instance (default: Logger.new($stdout))
+    # @option options [Integer] :listener_v2_timeout Timeout for listener v2 in milliseconds
+    # @option options [Integer] :grpc_max_recv_message_length Maximum gRPC receive message length (default: 4MB)
+    # @option options [Integer] :grpc_max_send_message_length Maximum gRPC send message length (default: 4MB)
+    # @option options [Hash] :worker_preset_labels Hash of preset labels for workers
+    # @option options [Boolean] :enable_force_kill_sync_threads Enable force killing of sync threads (default: false)
+    # @option options [Boolean] :enable_thread_pool_monitoring Enable thread pool monitoring (default: false)
+    # @option options [Integer] :terminate_worker_after_num_tasks Terminate worker after this many tasks
+    # @option options [Boolean] :disable_log_capture Disable log capture (default: false)
+    # @option options [Boolean] :grpc_enable_fork_support Enable gRPC fork support (default: false)
+    # @option options [TLSConfig] :tls_config Custom TLS configuration
+    # @option options [HealthcheckConfig] :healthcheck Custom healthcheck configuration
+    # @option options [OpenTelemetryConfig] :otel Custom OpenTelemetry configuration
+    #
+    # @raise [Error] if token or configuration is missing or invalid
+    #
+    # @example Initialize with minimal configuration
+    #   client = Hatchet::Client.new()
+    #
+    # @example Initialize with custom options
+    #   client = Hatchet::Client.new(
+    #     token: "eyJhbGciOiJIUzI1NiJ9...",
+    #     namespace: "my_app",
+    #     worker_preset_labels: { "env" => "production", "version" => "1.0.0" }
+    #   )
+    def initialize(**options)
+      @config = Config.new(**options)
+    end
+
+    def rest_client
+        @rest_client ||= Hatchet::Clients.rest_client(@config)
+    end
+
+    # Feature Client for interacting with Hatchet events
+    # @return [Hatchet::Features::Events] The events client for interacting with Hatchet events
+    def events
+      # @type [Hatchet::Features::Events]
+      @events ||= Hatchet::Features::Events.new(rest_client, @config)
+    end
+
+    # Feature Client for interacting with Hatchet workflow runs
+    # @return [Hatchet::Features::Runs] The runs client for interacting with Hatchet workflow runs
+    def runs
+      # @type [Hatchet::Features::Runs]
+      @runs ||= Hatchet::Features::Runs.new(rest_client, @config)
     end
   end
 end

data/scripts/generate.sh

@@ -0,0 +1,167 @@
+#!/bin/bash
+
+# Ruby SDK REST API Client Generation Script
+# Similar to the Python SDK's generate.sh
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+OPENAPI_SPEC="$PROJECT_ROOT/../../../../bin/oas/openapi.yaml"
+OUTPUT_DIR="$PROJECT_ROOT/lib/hatchet/clients/rest"
+CONFIG_FILE="$PROJECT_ROOT/config/openapi_generator_config.json"
+
+echo -e "${BLUE}🚀 Starting Ruby REST API Client Generation${NC}"
+echo "Project Root: $PROJECT_ROOT"
+
+# Function to check if a command exists
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+# Function to install OpenAPI Generator CLI
+install_openapi_generator() {
+    echo -e "${YELLOW}📦 Installing OpenAPI Generator CLI...${NC}"
+    
+    if command_exists npm; then
+        npm install -g @openapitools/openapi-generator-cli@7.13.0
+        echo -e "${GREEN}✅ OpenAPI Generator CLI installed${NC}"
+    else
+        echo -e "${RED}❌ npm not found. Please install Node.js and npm first.${NC}"
+        exit 1
+    fi
+}
+
+# Function to validate OpenAPI spec
+validate_spec() {
+    echo -e "${BLUE}🔍 Validating OpenAPI specification...${NC}"
+    
+    if [ ! -f "$OPENAPI_SPEC" ]; then
+        echo -e "${RED}❌ OpenAPI spec not found at: $OPENAPI_SPEC${NC}"
+        exit 1
+    fi
+    
+    openapi-generator-cli validate -i "$OPENAPI_SPEC"
+    echo -e "${GREEN}✅ OpenAPI specification is valid${NC}"
+}
+
+# Function to generate the REST client
+generate_client() {
+    echo -e "${BLUE}🏗️  Generating Ruby REST client...${NC}"
+    
+    # Create output directory
+    mkdir -p "$OUTPUT_DIR"
+    
+    # Additional properties for Ruby generation
+    ADDITIONAL_PROPS="gemName=hatchet-sdk-rest,moduleName=Hatchet::Clients::Rest,gemVersion=0.0.1,gemDescription=Ruby REST client for Hatchet API,gemAuthor=Hatchet Team,gemHomepage=https://github.com/hatchet-dev/hatchet,gemLicense=MIT,library=faraday,httpLibrary=faraday"
+    
+    # Generate the client
+    openapi-generator-cli generate \
+        -i "$OPENAPI_SPEC" \
+        -g ruby \
+        -o "$OUTPUT_DIR" \
+        -c "$CONFIG_FILE" \
+        --skip-validate-spec \
+        --global-property apiTests=false,modelTests=false,apiDocs=true,modelDocs=true \
+        --additional-properties "$ADDITIONAL_PROPS"
+    
+    echo -e "${GREEN}✅ Ruby REST client generated${NC}"
+}
+
+# Function to apply custom patches
+apply_patches() {
+    echo -e "${BLUE}🔧 Applying custom patches...${NC}"
+    
+    echo -e "${GREEN}✅ Custom patches applied${NC}"
+}
+
+# Function to update dependencies
+update_dependencies() {
+    echo -e "${BLUE}📦 Updating Ruby dependencies...${NC}"
+    
+    cd "$PROJECT_ROOT"
+    
+    # Add required gems to Gemfile if not present
+    if ! grep -q "gem ['\"]faraday['\"]" Gemfile 2>/dev/null; then
+        echo "gem 'faraday', '~> 2.0'" >> Gemfile
+    fi
+    
+    if ! grep -q "gem ['\"]faraday-multipart['\"]" Gemfile 2>/dev/null; then
+        echo "gem 'faraday-multipart'" >> Gemfile
+    fi
+    
+    # Install/update dependencies
+    bundle install
+    
+    echo -e "${GREEN}✅ Dependencies updated${NC}"
+}
+
+# Function to run tests on generated code
+run_tests() {
+    echo -e "${BLUE}🧪 Running tests...${NC}"
+    
+    cd "$PROJECT_ROOT"
+    
+    # Run RSpec tests
+    bundle exec rspec
+    
+    # Run RuboCop
+    bundle exec rubocop --auto-correct
+    
+    echo -e "${GREEN}✅ Tests completed${NC}"
+}
+
+# Main execution
+main() {
+    echo -e "${BLUE}Starting Ruby REST API generation process...${NC}"
+    
+    # Check if OpenAPI Generator CLI is installed
+    if ! command_exists openapi-generator-cli; then
+        echo -e "${YELLOW}OpenAPI Generator CLI not found${NC}"
+        install_openapi_generator
+    else
+        echo -e "${GREEN}✅ OpenAPI Generator CLI found${NC}"
+    fi
+    
+    # Validate the OpenAPI specification
+    validate_spec
+    
+    # Generate the REST client
+    generate_client
+    
+    # Apply custom patches
+    apply_patches
+    
+    # Update dependencies
+    update_dependencies
+    
+    # Run tests (optional, can be disabled with --skip-tests)
+    if [[ "$*" != *"--skip-tests"* ]]; then
+        run_tests
+    fi
+    
+    echo -e "${GREEN}🎉 Ruby REST API client generation completed successfully!${NC}"
+    echo -e "${BLUE}Generated files are in: $OUTPUT_DIR${NC}"
+}
+
+# Handle command line arguments
+case "$1" in
+    --help|-h)
+        echo "Usage: $0 [OPTIONS]"
+        echo "Options:"
+        echo "  --skip-tests    Skip running tests after generation"
+        echo "  --help, -h      Show this help message"
+        exit 0
+        ;;
+    *)
+        main "$@"
+        ;;
+esac

data/scripts/generate_api.rb

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Script to generate Ruby REST API client from OpenAPI specification
+# Similar to the Python SDK's generate.sh script
+
+require "fileutils"
+require "json"
+require "open3"
+
+class ApiGenerator
+  OPENAPI_SPEC_PATH = "../../../../bin/oas/openapi.yaml"
+  GENERATOR_CONFIG_PATH = "../config/openapi_generator_config.json"
+  OUTPUT_DIR = "../lib/hatchet/clients/rest"
+  TEMP_DIR = "../tmp/openapi_generation"
+
+  def initialize
+    @root_dir = __dir__
+    @patches_applied = 0
+  end
+
+  def generate
+    puts "🚀 Starting Ruby REST API client generation..."
+    
+    setup_directories
+    install_openapi_generator if needed
+    generate_client_code
+    apply_custom_patches
+    cleanup_temp_files
+    
+    puts "✅ Ruby REST API client generation completed successfully!"
+  end
+
+  private
+
+  def setup_directories
+    puts "📁 Setting up directories..."
+    FileUtils.mkdir_p(OUTPUT_DIR)
+    FileUtils.mkdir_p(TEMP_DIR)
+  end
+
+  def install_openapi_generator
+    puts "🔧 Checking OpenAPI Generator installation..."
+    
+    # Check if openapi-generator-cli is available
+    stdout, stderr, status = Open3.capture3("which openapi-generator-cli")
+    
+    if status.success?
+      puts "✅ OpenAPI Generator CLI found"
+    else
+      puts "📦 Installing OpenAPI Generator CLI via npm..."
+      system("npm install -g @openapitools/openapi-generator-cli@7.13.0") || 
+        raise("Failed to install OpenAPI Generator CLI")
+    end
+  end
+
+  def generate_client_code
+    puts "🏗️  Generating Ruby client code from OpenAPI spec..."
+    
+    openapi_spec = File.expand_path(OPENAPI_SPEC_PATH, @root_dir)
+    config_file = File.expand_path(GENERATOR_CONFIG_PATH, @root_dir)
+    output_path = File.expand_path(OUTPUT_DIR, @root_dir)
+    
+    unless File.exist?(openapi_spec)
+      raise "OpenAPI spec not found at #{openapi_spec}"
+    end
+    
+    unless File.exist?(config_file)
+      puts "⚠️  Config file not found at #{config_file}, using default configuration"
+      config_file = nil
+    else
+      puts "✅ Using config file: #{config_file}"
+    end
+    
+    # Generate Ruby client using OpenAPI Generator
+    additional_props = build_additional_properties
+    
+    cmd = [
+      "openapi-generator-cli", "generate",
+      "-i", openapi_spec,
+      "-g", "ruby",
+      "-o", output_path,
+      "--skip-validate-spec",
+      "--global-property", "apiTests=false,modelTests=false,apiDocs=true,modelDocs=true",
+      "--additional-properties", additional_props
+    ]
+    
+    cmd += ["-c", config_file] if config_file
+    
+    puts "Running: #{cmd.join(' ')}"
+    puts "Additional properties: #{additional_props}"
+    system(*cmd) || raise("Failed to generate Ruby client code")
+  end
+
+  def build_additional_properties
+    [
+      "gemName=hatchet-sdk-rest",
+      "moduleName=HatchetSdkRest", 
+      "gemVersion=0.0.1",
+      "gemDescription=HatchetRubySDKRestClient",
+      "gemAuthor=HatchetTeam",
+      "gemHomepage=https://github.com/hatchet-dev/hatchet",
+      "gemLicense=MIT",
+      "library=faraday"
+    ].join(",")
+  end
+
+  def apply_custom_patches
+    puts "🔧 Applying custom patches..."
+    
+    # Apply Ruby-specific patches here
+    patch_require_statements
+    patch_cookie_auth
+  end
+
+  def patch_require_statements
+    puts "  📝 Patching require statements..."
+    
+    # Find all generated Ruby files and fix require statements
+    Dir.glob("#{OUTPUT_DIR}/**/*.rb").each do |file|
+      content = File.read(file)
+      
+      # Update require paths to be relative to the gem structure
+      content.gsub!(/require ['"]hatchet-sdk-rest\//, "require 'hatchet/clients/rest/")
+      
+      # Ensure consistent module naming
+      content.gsub!(/module HatchetSdkRest/, "module Hatchet\n  module Clients\n    module Rest")
+      content.gsub!(/^end$/, "    end\n  end\nend") if content.include?("module Hatchet")
+      
+      File.write(file, content)
+    end
+  end
+
+  def patch_cookie_auth
+    puts "  🍪 Enhancing cookie auth..."
+    # find the auth_settings hash in the configuration.rb file
+    output_path = File.expand_path(OUTPUT_DIR, @root_dir)
+    config_file = File.join(output_path, "lib/hatchet-sdk-rest/configuration.rb")
+    if not File.exist?(config_file)
+      puts "config_file does not exist"
+      return false
+    end
+    content = File.read(config_file)
+    
+    # Apply the fix - replace 'in: ,' with 'in: 'header','
+    if content.gsub!(/in:\s*,/, "in: 'header',")
+      puts "    ✅ Successfully applied cookie auth patch"
+      File.write(config_file, content)
+      @patches_applied += 1
+    else
+      puts "    ❌ Failed to apply cookie auth patch - no matches found"
+    end
+  end
+
+  def cleanup_temp_files
+    puts "🧹 Cleaning up temporary files..."
+    FileUtils.rm_rf(TEMP_DIR) if Dir.exist?(TEMP_DIR)
+  end
+
+  def needed
+    !system("which openapi-generator-cli > /dev/null 2>&1")
+  end
+end
+
+# Run the generator if this script is executed directly
+if __FILE__ == $0
+  begin
+    ApiGenerator.new.generate
+  rescue => e
+    puts "❌ Generation failed: #{e.message}"
+    puts e.backtrace.join("\n") if ENV["DEBUG"]
+    exit 1
+  end
+end