hatchet-sdk 0.0.1 → 0.1.0.pre.alpha

data/lib/hatchet/clients/rest.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+# typed: strict
+
+require 'fileutils'
+require 'rbconfig'
+
+# Integration file for generated Hatchet REST API client
+# This file loads the generated REST client and makes it available under the Hatchet::Clients::Rest namespace
+
+begin
+  # Set up load paths for the generated client
+  rest_lib_path = File.expand_path("rest/lib", __dir__)
+  $LOAD_PATH.unshift(rest_lib_path) unless $LOAD_PATH.include?(rest_lib_path)
+  
+  # Create an alias so hatchet-sdk-rest/ paths resolve to the actual location
+  # This is a bit of a hack, but necessary because the generator expects gem-style paths
+  hatchet_sdk_rest_base = File.expand_path("rest/lib/hatchet-sdk-rest", __dir__)
+  $LOAD_PATH.unshift(hatchet_sdk_rest_base) unless $LOAD_PATH.include?(hatchet_sdk_rest_base)
+  
+  # Create a symlink in the load path to make hatchet-sdk-rest/ paths work
+  fake_gem_path = File.expand_path("rest/lib/hatchet-sdk-rest/hatchet-sdk-rest", __dir__)
+  unless File.exist?(fake_gem_path)
+    FileUtils.mkdir_p(File.dirname(fake_gem_path))
+    # On Unix systems, create a symlink; on Windows, copy the files
+    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+      require 'fileutils'
+      FileUtils.cp_r(hatchet_sdk_rest_base, fake_gem_path)
+    else
+      File.symlink(hatchet_sdk_rest_base, fake_gem_path)
+    end
+  end
+  
+  # Load the generated REST client
+  require_relative "rest/lib/hatchet-sdk-rest"
+  
+  # The generated client creates classes under HatchetSdkRest module
+  # We need to alias them to our desired namespace structure
+  module Hatchet
+    module Clients
+      module Rest
+        # Re-export the main classes from the generated client
+        ApiClient = ::HatchetSdkRest::ApiClient
+        ApiError = ::HatchetSdkRest::ApiError
+        
+        # Enhanced Configuration class with Hatchet integration
+        class Configuration < ::HatchetSdkRest::Configuration
+          # Create a Configuration instance from a Hatchet::Config
+          #
+          # @param hatchet_config [Hatchet::Config] The main Hatchet configuration
+          # @return [Configuration] Configured REST client configuration
+          def self.from_hatchet_config(hatchet_config)
+            config = new
+            config.access_token = hatchet_config.token
+            
+            # Extract host from server_url
+            if hatchet_config.server_url && !hatchet_config.server_url.empty?
+              config.host = hatchet_config.server_url.gsub(/^https?:\/\//, '').split('/').first
+              config.scheme = hatchet_config.server_url.start_with?('https') ? 'https' : 'http'
+            end
+            
+            # Set timeout if available
+            if hatchet_config.listener_v2_timeout
+              config.timeout = hatchet_config.listener_v2_timeout / 1000.0 # Convert ms to seconds
+            end
+            
+            config
+          end
+        end
+        
+        # Re-export API classes
+        WorkflowApi = ::HatchetSdkRest::WorkflowApi
+        EventApi = ::HatchetSdkRest::EventApi
+        StepRunApi = ::HatchetSdkRest::StepRunApi
+        WorkflowRunApi = ::HatchetSdkRest::WorkflowRunApi
+        WorkflowRunsApi = ::HatchetSdkRest::WorkflowRunsApi
+        TenantApi = ::HatchetSdkRest::TenantApi
+        UserApi = ::HatchetSdkRest::UserApi
+        WorkerApi = ::HatchetSdkRest::WorkerApi
+        
+        # Re-export commonly used model classes
+        CreateEventRequest = ::HatchetSdkRest::CreateEventRequest
+        Event = ::HatchetSdkRest::Event
+        
+        # Add more API classes and models as needed - you can extend this list
+        # with any other generated API classes or models you want to expose
+      end
+    end
+  end
+  
+rescue LoadError => e
+  # If the generated client files are not available, define an empty module
+  # This allows the main SDK to load without errors even before generation
+  warn "REST client not fully loaded: #{e.message}" if ENV["DEBUG"]
+  
+  module Hatchet
+    module Clients
+      module Rest
+        # Placeholder classes that will raise helpful errors
+        class ApiClient
+          def initialize(*)
+            raise LoadError, "REST client not generated. Run `rake api:generate` to generate it."
+          end
+        end
+        
+        class Configuration
+          def self.from_hatchet_config(*)
+            raise LoadError, "REST client not generated. Run `rake api:generate` to generate it."
+          end
+        end
+        
+        # Placeholder model classes
+        class CreateEventRequest
+          def initialize(*)
+            raise LoadError, "REST client not generated. Run `rake api:generate` to generate it."
+          end
+        end
+        
+        class Event
+          def initialize(*)
+            raise LoadError, "REST client not generated. Run `rake api:generate` to generate it."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hatchet/clients.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+# typed: strict
+
+# Hatchet clients module
+# This module provides access to different client types (REST, gRPC, etc.)
+
+module Hatchet
+  # Client implementations for different protocols
+  module Clients
+    # Load REST client if available
+    begin
+      require_relative "clients/rest"
+    rescue LoadError
+      # REST client not generated yet - this is expected initially
+      # Run `rake api:generate` to generate the REST client
+    end
+
+    # Factory methods for creating pre-configured clients
+    class << self
+      # Create a REST API client using the provided Hatchet configuration
+      #
+      # @param config [Hatchet::Config] The main Hatchet configuration
+      # @return [Hatchet::Clients::Rest::ApiClient] Configured REST API client
+      # @raise [LoadError] if REST client hasn't been generated yet
+      #
+      # @example Create a REST client
+      #   config = Hatchet::Config.new(token: "your-jwt-token")
+      #   rest_client = Hatchet::Clients.rest_client(config)
+      #   workflows_api = Hatchet::Clients::Rest::WorkflowApi.new(rest_client)
+      def rest_client(config)
+        unless rest_available?
+          raise LoadError, "REST client not available. Run `rake api:generate` to generate it from the OpenAPI spec."
+        end
+
+        rest_config = Rest::Configuration.from_hatchet_config(config)
+        Rest::ApiClient.new(rest_config)
+      end
+
+      # Check if REST client is available
+      #
+      # @return [Boolean] true if REST client has been generated and is available
+      def rest_available?
+        return false unless defined?(Hatchet::Clients::Rest)
+        
+        # Check if this is the real implementation or just the placeholder
+        # The placeholder Configuration.from_hatchet_config raises LoadError
+        begin
+          # Try to access a method that should exist in the real implementation
+          # If it's the placeholder, this will raise LoadError
+          Hatchet::Clients::Rest::Configuration.method(:from_hatchet_config)
+          
+          # Try creating a dummy configuration to ensure the real client is loaded
+          dummy_config = Struct.new(:token, :server_url, :listener_v2_timeout).new("test", "", nil)
+          Hatchet::Clients::Rest::Configuration.from_hatchet_config(dummy_config)
+          true
+        rescue LoadError
+          false
+        end
+      end
+
+      # List available client types
+      #
+      # @return [Array<Symbol>] List of available client types
+      def available_clients
+        clients = []
+        clients << :rest if rest_available?
+        clients
+      end
+    end
+  end
+end

data/lib/hatchet/config.rb

@@ -149,7 +149,6 @@ module Hatchet
   #     host_port: "localhost:7070",
   #     server_url: "https://api.hatchet.com",
   #     namespace: "production",
-  #     tenant_id: "custom-tenant",
   #     worker_preset_labels: { "env" => "prod", "region" => "us-east-1" }
   #   )
   #
@@ -200,12 +199,14 @@ module Hatchet
     #   @return [HealthcheckConfig] Healthcheck configuration
     # @!attribute otel
     #   @return [OpenTelemetryConfig] OpenTelemetry configuration
-    attr_accessor :token, :tenant_id, :host_port, :server_url, :namespace,
+    attr_accessor :token, :host_port, :server_url, :namespace,
                   :logger, :listener_v2_timeout, :grpc_max_recv_message_length,
                   :grpc_max_send_message_length, :worker_preset_labels,
                   :enable_force_kill_sync_threads, :enable_thread_pool_monitoring,
                   :terminate_worker_after_num_tasks, :disable_log_capture,
                   :grpc_enable_fork_support, :tls_config, :healthcheck, :otel
+    
+    attr_reader :tenant_id
 
     # Initialize a new configuration instance
     #
@@ -217,7 +218,6 @@ module Hatchet
     #
     # @param options [Hash] Configuration options
     # @option options [String] :token JWT token for authentication (required)
-    # @option options [String] :tenant_id Override tenant ID (extracted from JWT '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: "")
@@ -241,7 +241,6 @@ module Hatchet
       @explicitly_set = options.keys.to_set
 
       @token = options[:token] || env_var("HATCHET_CLIENT_TOKEN") || ""
-      @tenant_id = options[:tenant_id] || env_var("HATCHET_CLIENT_TENANT_ID") || ""
       @host_port = options[:host_port] || env_var("HATCHET_CLIENT_HOST_PORT") || DEFAULT_HOST_PORT
       @server_url = options[:server_url] || env_var("HATCHET_CLIENT_SERVER_URL") || DEFAULT_SERVER_URL
       @namespace = options[:namespace] || env_var("HATCHET_CLIENT_NAMESPACE") || ""
@@ -285,6 +284,9 @@ module Hatchet
       @healthcheck = options[:healthcheck] || HealthcheckConfig.new
       @otel = options[:otel] || OpenTelemetryConfig.new
 
+      # Initialize tenant_id from JWT token
+      @tenant_id = ""
+
       validate!
       apply_token_defaults if valid_jwt_token?
       apply_address_defaults if valid_jwt_token?
@@ -335,7 +337,6 @@ module Hatchet
     def to_h
       {
         token: token,
-        tenant_id: tenant_id,
         host_port: host_port,
         server_url: server_url,
         namespace: namespace,
@@ -358,8 +359,7 @@ module Hatchet
     end
 
     def apply_token_defaults
-      return unless tenant_id.empty?
-
+      # tenant_id is only set from JWT token, not from environment variables or parameters
       extracted_tenant_id = extract_tenant_id_from_jwt
       @tenant_id = extracted_tenant_id || ""
     end

data/lib/hatchet/features/events.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Hatchet
+  module Features
+    # Events client for interacting with Hatchet event management API
+    #
+    # This class provides a high-level interface for creating and managing events
+    # in the Hatchet system. It wraps the generated REST API client with a more
+    # convenient Ruby interface.
+    #
+    # @example Creating an event
+    #   response = events.push(
+    #     key: "user-login",
+    #     data: { user_id: 123, action: "login" },
+    #     additional_metadata: { ip_address: "192.168.1.1" }
+    #   )
+    #
+    # @since 0.1.0
+    class Events
+      # Re-export commonly used event classes for convenience
+      CreateEventRequest = ::HatchetSdkRest::CreateEventRequest
+      BulkCreateEventRequest = ::HatchetSdkRest::BulkCreateEventRequest
+      EventList = ::HatchetSdkRest::V1EventList
+
+      # Initializes a new Events client instance
+      #
+      # @param rest_client [Object] The configured REST client for API communication
+      # @param config [Hatchet::Config] The Hatchet configuration containing tenant_id and other settings
+      # @return [void]
+      # @since 0.1.0
+      def initialize(rest_client, config)
+        @rest_client = rest_client
+        @config = config
+        @event_api = HatchetSdkRest::EventApi.new(rest_client)
+      end
+
+      # Creates a new event in the Hatchet system
+      #
+      # This method sends an event creation request to the Hatchet API using the
+      # configured tenant ID. The event will be processed and made available for
+      # workflow triggers and event-driven automation.
+      #
+      # @param key [String] The event key/name
+      # @param data [Hash] The event payload data
+      # @param additional_metadata [Hash, nil] Additional metadata for the event
+      # @param priority [Integer, nil] Event priority
+      # @param scope [String, nil] The scope for event filtering
+      # @param namespace [String, nil] Override namespace for this event
+      # @return [Object] The API response containing the created event details
+      # @raise [ArgumentError] If required parameters are missing
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      # @example Creating a simple event
+      #   response = events.create(
+      #     key: "user-login",
+      #     data: { user_id: 123, action: "login" },
+      #     additional_metadata: { ip_address: "192.168.1.1" }
+      #   )
+      # @since 0.1.0
+      def create(key:, data:, additional_metadata: nil, priority: nil, scope: nil, namespace: nil)
+        event_key = apply_namespace(key, namespace)
+        
+        event_request = HatchetSdkRest::CreateEventRequest.new(
+          key: event_key,
+          data: data,
+          additional_metadata: additional_metadata,
+          priority: priority,
+          scope: scope
+        )
+        
+        @event_api.event_create(@config.tenant_id, event_request)
+      end
+
+      # Push a single event to Hatchet
+      #
+      # @param event_key [String] The event key/name
+      # @param payload [Hash] The event payload data
+      # @param additional_metadata [Hash, nil] Additional metadata for the event
+      # @param namespace [String, nil] Override namespace for this event
+      # @param priority [Integer, nil] Event priority
+      # @return [Object] The API response containing the created event details
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      # @example Push a simple event
+      #   response = events.push(
+      #     "user-signup",
+      #     { user_id: 456, email: "user@example.com" },
+      #     additional_metadata: { source: "web" }
+      #   )
+      def push(event_key, payload, additional_metadata: nil, namespace: nil, priority: nil)
+        create(
+          key: event_key,
+          data: payload,
+          additional_metadata: additional_metadata,
+          priority: priority,
+          namespace: namespace
+        )
+      end
+
+      # Create events in bulk
+      #
+      # @param events [Array<Hash>] Array of event hashes, each containing :key, :data, and optionally :additional_metadata and :priority
+      # @param namespace [String, nil] Override namespace for all events
+      # @return [Object] The API response containing the created events
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      # @example Bulk create events
+      #   events_data = [
+      #     { key: "user-signup", data: { user_id: 1 } },
+      #     { key: "user-login", data: { user_id: 1 }, priority: 1 }
+      #   ]
+      #   response = events.bulk_push(events_data)
+      def bulk_push(events, namespace: nil)
+        events_requests = events.map do |event|
+          event_key = apply_namespace(event[:key], namespace)
+          
+          HatchetSdkRest::CreateEventRequest.new(
+            key: event_key,
+            data: event[:data] || {},
+            additional_metadata: event[:additional_metadata],
+            priority: event[:priority]
+          )
+        end
+        
+        bulk_request = HatchetSdkRest::BulkCreateEventRequest.new(
+          events: events_requests
+        )
+        
+        @event_api.event_create_bulk(@config.tenant_id, bulk_request)
+      end
+
+      # List events with filtering options
+      #
+      # @param offset [Integer, nil] Pagination offset
+      # @param limit [Integer, nil] Maximum number of events to return
+      # @param keys [Array<String>, nil] Filter by event keys
+      # @param since [Time, nil] Filter events after this time
+      # @param until_time [Time, nil] Filter events before this time
+      # @param workflow_ids [Array<String>, nil] Filter by workflow IDs
+      # @param workflow_run_statuses [Array<String>, nil] Filter by workflow run statuses
+      # @param event_ids [Array<String>, nil] Filter by specific event IDs
+      # @param additional_metadata [Hash<String, String>, nil] Filter by additional metadata
+      # @param scopes [Array<String>, nil] Filter by event scopes
+      # @return [HatchetSdkRest::V1EventList] List of events matching the filters
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      # @example List recent events
+      #   events = events_client.list(
+      #     limit: 10,
+      #     since: Time.now - 24 * 60 * 60,
+      #     keys: ["user-signup", "user-login"]
+      #   )
+      def list(
+        offset: nil,
+        limit: nil,
+        keys: nil,
+        since: nil,
+        until_time: nil,
+        workflow_ids: nil,
+        workflow_run_statuses: nil,
+        event_ids: nil,
+        additional_metadata: nil,
+        scopes: nil
+      )
+        @event_api.v1_event_list(
+          @config.tenant_id,
+          {
+            offset: offset,
+            limit: limit,
+            keys: keys,
+            since: since&.utc&.iso8601,
+            until: until_time&.utc&.iso8601,
+            workflow_ids: workflow_ids,
+            workflow_run_statuses: workflow_run_statuses,
+            event_ids: event_ids,
+            additional_metadata: maybe_additional_metadata_to_kv(additional_metadata),
+            scopes: scopes
+          }
+        )
+      end
+
+      # Get a specific event by ID
+      #
+      # @param event_id [String] The event ID
+      # @return [Object] The event details
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      def get(event_id)
+        @event_api.event_get(event_id)
+      end
+
+      # Get event data for a specific event
+      #
+      # @param event_id [String] The event ID
+      # @return [Object] The event data
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      def get_data(event_id)
+        @event_api.event_data_get(event_id)
+      end
+
+      # List available event keys for the tenant
+      #
+      # @return [Object] List of available event keys
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      def list_keys
+        @event_api.v1_event_key_list(@config.tenant_id)
+      end
+
+      # Cancel events matching the given criteria
+      #
+      # @param event_ids [Array<String>, nil] Specific event IDs to cancel
+      # @param keys [Array<String>, nil] Event keys to cancel
+      # @param since [Time, nil] Cancel events after this time
+      # @param until_time [Time, nil] Cancel events before this time
+      # @return [Object] The cancellation response
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      def cancel(event_ids: nil, keys: nil, since: nil, until_time: nil)
+        cancel_request = HatchetSdkRest::CancelEventRequest.new(
+          event_ids: event_ids,
+          keys: keys,
+          since: since&.utc&.iso8601,
+          until: until_time&.utc&.iso8601
+        )
+        
+        @event_api.event_update_cancel(@config.tenant_id, cancel_request)
+      end
+
+      # Replay events matching the given criteria
+      #
+      # @param event_ids [Array<String>, nil] Specific event IDs to replay
+      # @param keys [Array<String>, nil] Event keys to replay
+      # @param since [Time, nil] Replay events after this time
+      # @param until_time [Time, nil] Replay events before this time
+      # @return [Object] The replay response
+      # @raise [Hatchet::Error] If the API request fails or returns an error
+      def replay(event_ids: nil, keys: nil, since: nil, until_time: nil)
+        replay_request = HatchetSdkRest::ReplayEventRequest.new(
+          event_ids: event_ids,
+          keys: keys,
+          since: since&.utc&.iso8601,
+          until: until_time&.utc&.iso8601
+        )
+        
+        @event_api.event_update_replay(@config.tenant_id, replay_request)
+      end
+
+      private
+
+      # Apply namespace to event key
+      #
+      # @param event_key [String] The original event key
+      # @param namespace_override [String, nil] Optional namespace override
+      # @return [String] The namespaced event key
+      def apply_namespace(event_key, namespace_override = nil)
+        @config.apply_namespace(event_key, namespace_override: namespace_override)
+      end
+
+      # Convert additional metadata hash to key-value array format expected by API
+      #
+      # @param metadata [Hash<String, String>, nil] Metadata hash
+      # @return [Array<Hash>, nil] Array of {key: string, value: string} objects
+      def maybe_additional_metadata_to_kv(metadata)
+        return nil unless metadata
+        metadata.map { |k, v| { key: k.to_s, value: v.to_s } }
+      end
+    end
+  end
+end