conductor_ruby 0.1.0

data/lib/conductor/client/metadata_client.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative '../configuration'
+require_relative '../http/api_client'
+require_relative '../http/api/metadata_resource_api'
+
+module Conductor
+  module Client
+    # MetadataClient - High-level client for workflow and task metadata operations
+    # Provides a clean interface for registering and managing workflow/task definitions
+    class MetadataClient
+      attr_reader :metadata_api
+
+      # Initialize MetadataClient
+      # @param [Configuration] configuration Optional configuration
+      def initialize(configuration = nil)
+        @configuration = configuration || Configuration.new
+        api_client = Http::ApiClient.new(configuration: @configuration)
+        @metadata_api = Http::Api::MetadataResourceApi.new(api_client)
+      end
+
+      # ==========================================
+      # Workflow Definition Operations
+      # ==========================================
+
+      # Register a workflow definition
+      # @param [WorkflowDef] workflow_def Workflow definition to register
+      # @param [Boolean] overwrite Overwrite existing definition (default: true)
+      # @return [void]
+      def register_workflow_def(workflow_def, overwrite: true)
+        @metadata_api.create_workflow(workflow_def, overwrite: overwrite)
+      end
+
+      # Update a workflow definition
+      # @param [WorkflowDef] workflow_def Workflow definition to update
+      # @param [Boolean] overwrite Overwrite existing definition (default: true)
+      # @return [void]
+      def update_workflow_def(workflow_def, overwrite: true)
+        @metadata_api.update_workflows([workflow_def], overwrite: overwrite)
+      end
+
+      # Unregister (delete) a workflow definition
+      # @param [String] name Workflow name
+      # @param [Integer] version Workflow version
+      # @return [void]
+      def unregister_workflow_def(name, version:)
+        @metadata_api.unregister_workflow_def(name, version: version)
+      end
+
+      # Get a workflow definition by name
+      # @param [String] name Workflow name
+      # @param [Integer] version Workflow version (optional, returns latest if not specified)
+      # @return [WorkflowDef] Workflow definition
+      def get_workflow_def(name, version: nil)
+        @metadata_api.get_workflow_def(name, version: version)
+      end
+
+      # Get all workflow definitions
+      # @return [Array<WorkflowDef>] List of workflow definitions
+      def get_all_workflow_defs
+        @metadata_api.get_all_workflows
+      end
+
+      # ==========================================
+      # Task Definition Operations
+      # ==========================================
+
+      # Register a task definition
+      # @param [TaskDef] task_def Task definition to register
+      # @return [void]
+      def register_task_def(task_def)
+        @metadata_api.register_task_def([task_def])
+      end
+
+      # Register multiple task definitions
+      # @param [Array<TaskDef>] task_defs List of task definitions to register
+      # @return [void]
+      def register_task_defs(task_defs)
+        @metadata_api.register_task_def(task_defs)
+      end
+
+      # Update a task definition
+      # @param [TaskDef] task_def Task definition to update
+      # @return [void]
+      def update_task_def(task_def)
+        @metadata_api.update_task_def(task_def)
+      end
+
+      # Unregister (delete) a task definition
+      # @param [String] task_type Task type name
+      # @return [void]
+      def unregister_task_def(task_type)
+        @metadata_api.unregister_task_def(task_type)
+      end
+
+      # Get a task definition by name
+      # @param [String] task_type Task type name
+      # @return [TaskDef] Task definition
+      def get_task_def(task_type)
+        @metadata_api.get_task_def(task_type)
+      end
+
+      # Get all task definitions
+      # @return [Array<TaskDef>] List of task definitions
+      def get_all_task_defs
+        @metadata_api.get_all_task_defs
+      end
+
+      # ==========================================
+      # Workflow Metadata (Tags) Operations
+      # ==========================================
+
+      # Add metadata (tags) to a workflow
+      # @param [String] workflow_name Workflow name
+      # @param [Object] tag Tag/metadata to add
+      # @param [Integer] version Workflow version (optional)
+      # @return [void]
+      def add_workflow_tag(workflow_name, tag, version: nil)
+        @metadata_api.create_workflow_metadata(workflow_name, tag, version: version)
+      end
+
+      # Get metadata (tags) for a workflow
+      # @param [String] workflow_name Workflow name
+      # @param [Integer] version Workflow version (optional)
+      # @return [Object] Workflow metadata/tags
+      def get_workflow_tags(workflow_name, version: nil)
+        @metadata_api.get_workflow_metadata(workflow_name, version: version)
+      end
+
+      # Delete metadata (tags) from a workflow
+      # @param [String] workflow_name Workflow name
+      # @param [Integer] version Workflow version
+      # @return [void]
+      def delete_workflow_tag(workflow_name, version:)
+        @metadata_api.delete_workflow_metadata(workflow_name, version: version)
+      end
+    end
+  end
+end

data/lib/conductor/client/prompt_client.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Client
+    # PromptClient - High-level client for prompt template management operations (Orkes)
+    class PromptClient
+      def initialize(api_client)
+        @prompt_api = Http::Api::PromptResourceApi.new(api_client)
+      end
+
+      def save_prompt(prompt_name, description, prompt_template, models: nil, version: nil, auto_increment: false)
+        @prompt_api.save_prompt(
+          prompt_name, prompt_template,
+          description: description, models: models,
+          version: version, auto_increment: auto_increment
+        )
+      end
+
+      def get_prompt(prompt_name)
+        @prompt_api.get_prompt(prompt_name)
+      end
+
+      def get_prompts
+        @prompt_api.get_prompts
+      end
+
+      def delete_prompt(prompt_name)
+        @prompt_api.delete_prompt(prompt_name)
+      end
+
+      def get_tags_for_prompt_template(prompt_name)
+        @prompt_api.get_tags_for_prompt_template(prompt_name)
+      end
+
+      def update_tag_for_prompt_template(prompt_name, tags)
+        @prompt_api.update_tag_for_prompt_template(prompt_name, tags)
+      end
+
+      def delete_tag_for_prompt_template(prompt_name, tags)
+        @prompt_api.delete_tag_for_prompt_template(prompt_name, tags)
+      end
+
+      def test_prompt(prompt_text, variables, ai_integration, text_complete_model, temperature: 0.1, top_p: 0.9,
+                      stop_words: nil)
+        request = Http::Models::PromptTemplateTestRequest.new(
+          prompt: prompt_text,
+          prompt_variables: variables,
+          llm_provider: ai_integration,
+          model: text_complete_model,
+          temperature: temperature,
+          top_p: top_p,
+          stop_words: stop_words
+        )
+        @prompt_api.test_prompt(request)
+      end
+    end
+  end
+end

data/lib/conductor/client/scheduler_client.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative '../configuration'
+require_relative '../http/api_client'
+require_relative '../http/api/scheduler_resource_api'
+
+module Conductor
+  module Client
+    # SchedulerClient - High-level client for workflow schedule operations
+    class SchedulerClient
+      attr_reader :scheduler_api
+
+      # Initialize SchedulerClient
+      # @param [Configuration] configuration Optional configuration
+      def initialize(configuration = nil)
+        @configuration = configuration || Configuration.new
+        api_client = Http::ApiClient.new(configuration: @configuration)
+        @scheduler_api = Http::Api::SchedulerResourceApi.new(api_client)
+      end
+
+      # Save (create/update) a schedule
+      # @param [SaveScheduleRequest] request Schedule request
+      # @return [void]
+      def save_schedule(request)
+        @scheduler_api.save_schedule(request)
+      end
+
+      # Get a schedule by name
+      # @param [String] name Schedule name
+      # @return [WorkflowSchedule]
+      def get_schedule(name)
+        @scheduler_api.get_schedule(name)
+      end
+
+      # Get all schedules
+      # @param [String] workflow_name Filter by workflow name (optional)
+      # @return [Array<WorkflowSchedule>]
+      def get_all_schedules(workflow_name: nil)
+        @scheduler_api.get_all_schedules(workflow_name: workflow_name)
+      end
+
+      # Delete a schedule
+      # @param [String] name Schedule name
+      # @return [void]
+      def delete_schedule(name)
+        @scheduler_api.delete_schedule(name)
+      end
+
+      # Pause a schedule
+      # @param [String] name Schedule name
+      # @return [void]
+      def pause_schedule(name)
+        @scheduler_api.pause_schedule(name)
+      end
+
+      # Resume a schedule
+      # @param [String] name Schedule name
+      # @return [void]
+      def resume_schedule(name)
+        @scheduler_api.resume_schedule(name)
+      end
+
+      # Pause all schedules
+      # @return [Hash]
+      def pause_all_schedules
+        @scheduler_api.pause_all_schedules
+      end
+
+      # Resume all schedules
+      # @return [Hash]
+      def resume_all_schedules
+        @scheduler_api.resume_all_schedules
+      end
+
+      # Get next few schedule execution times
+      # @param [String] cron_expression Cron expression
+      # @param [Integer] schedule_start_time Start time (epoch ms, optional)
+      # @param [Integer] schedule_end_time End time (epoch ms, optional)
+      # @param [Integer] limit Number of times to return (optional)
+      # @return [Array<Integer>]
+      def get_next_few_schedule_execution_times(cron_expression, schedule_start_time: nil, schedule_end_time: nil,
+                                                limit: nil)
+        @scheduler_api.get_next_few_schedules(
+          cron_expression,
+          schedule_start_time: schedule_start_time,
+          schedule_end_time: schedule_end_time,
+          limit: limit
+        )
+      end
+
+      # Search schedule executions
+      # @param [Integer] start Start index (default: 0)
+      # @param [Integer] size Page size (default: 100)
+      # @param [String] sort Sort order (optional)
+      # @param [String] free_text Free text search (default: '*')
+      # @param [String] query Query string (optional)
+      # @return [SearchResult]
+      def search_schedule_executions(start: 0, size: 100, sort: nil, free_text: '*', query: nil)
+        @scheduler_api.search_v2(start: start, size: size, sort: sort, free_text: free_text, query: query)
+      end
+
+      # Requeue all execution records
+      # @return [Hash]
+      def requeue_all_execution_records
+        @scheduler_api.requeue_all_execution_records
+      end
+
+      # Set tags for a schedule
+      # @param [String] name Schedule name
+      # @param [Array<Hash>] tags Tags to set
+      # @return [void]
+      def set_scheduler_tags(name, tags)
+        @scheduler_api.put_tag_for_schedule(name, tags)
+      end
+
+      # Get tags for a schedule
+      # @param [String] name Schedule name
+      # @return [Array<Hash>]
+      def get_scheduler_tags(name)
+        @scheduler_api.get_tags_for_schedule(name)
+      end
+
+      # Delete tags for a schedule
+      # @param [String] name Schedule name
+      # @param [Array<Hash>] tags Tags to delete
+      # @return [void]
+      def delete_scheduler_tags(name, tags)
+        @scheduler_api.delete_tag_for_schedule(name, tags)
+      end
+    end
+  end
+end

data/lib/conductor/client/schema_client.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Client
+    # SchemaClient - High-level client for schema management operations (Orkes)
+    class SchemaClient
+      def initialize(api_client)
+        @schema_api = Http::Api::SchemaResourceApi.new(api_client)
+      end
+
+      def register_schema(schema, new_version: false)
+        @schema_api.save(schema, new_version: new_version)
+      end
+
+      def get_schema(schema_name, version)
+        @schema_api.get_schema_by_name_and_version(schema_name, version)
+      end
+
+      def get_all_schemas
+        @schema_api.get_all_schemas
+      end
+
+      def delete_schema(schema_name, version)
+        @schema_api.delete_schema_by_name_and_version(schema_name, version)
+      end
+
+      def delete_schema_by_name(schema_name)
+        @schema_api.delete_schema_by_name(schema_name)
+      end
+    end
+  end
+end

data/lib/conductor/client/secret_client.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Client
+    # SecretClient - High-level client for secret management operations (Orkes)
+    class SecretClient
+      def initialize(api_client)
+        @secret_api = Http::Api::SecretResourceApi.new(api_client)
+      end
+
+      def put_secret(key, value)
+        @secret_api.put_secret(value, key)
+      end
+
+      def get_secret(key)
+        @secret_api.get_secret(key)
+      end
+
+      def list_all_secret_names
+        @secret_api.list_all_secret_names
+      end
+
+      def list_secrets_that_user_can_grant_access_to
+        @secret_api.list_secrets_that_user_can_grant_access_to
+      end
+
+      def delete_secret(key)
+        @secret_api.delete_secret(key)
+      end
+
+      def secret_exists(key)
+        @secret_api.secret_exists(key)
+      end
+
+      def set_secret_tags(tags, key)
+        @secret_api.put_tag_for_secret(tags, key)
+      end
+
+      def get_secret_tags(key)
+        @secret_api.get_tags(key)
+      end
+
+      def delete_secret_tags(tags, key)
+        @secret_api.delete_tag_for_secret(tags, key)
+      end
+    end
+  end
+end

data/lib/conductor/client/task_client.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative '../configuration'
+require_relative '../http/api_client'
+require_relative '../http/api/task_resource_api'
+
+module Conductor
+  module Client
+    # TaskClient - High-level client for task operations
+    class TaskClient
+      attr_reader :task_api
+
+      # Initialize TaskClient
+      # @param [Configuration] configuration Optional configuration
+      def initialize(configuration = nil)
+        @configuration = configuration || Configuration.new
+        api_client = Http::ApiClient.new(configuration: @configuration)
+        @task_api = Http::Api::TaskResourceApi.new(api_client)
+      end
+
+      # Poll for a task
+      # @param [String] task_type Task type to poll
+      # @param [String] worker_id Worker ID (optional)
+      # @param [String] domain Domain (optional)
+      # @return [Task, nil] Task object or nil if no task available
+      def poll_task(task_type, worker_id: nil, domain: nil)
+        @task_api.poll(task_type, worker_id: worker_id, domain: domain)
+      end
+
+      # Batch poll for tasks
+      # @param [String] task_type Task type to poll
+      # @param [Integer] count Number of tasks to poll (default: 1)
+      # @param [Integer] timeout Timeout in milliseconds (default: 100)
+      # @param [String] worker_id Worker ID (optional)
+      # @param [String] domain Domain (optional)
+      # @return [Array<Task>] Array of tasks
+      def batch_poll_tasks(task_type, count: 1, timeout: 100, worker_id: nil, domain: nil)
+        @task_api.batch_poll(task_type, count: count, timeout: timeout, worker_id: worker_id, domain: domain)
+      end
+
+      # Update task status
+      # @param [TaskResult] task_result Task result
+      # @return [String] Task ID
+      def update_task(task_result)
+        @task_api.update_task(task_result)
+      end
+
+      # Get task details
+      # @param [String] task_id Task ID
+      # @return [Task] Task object
+      def get_task(task_id)
+        @task_api.get_task(task_id)
+      end
+
+      # Remove task from queue
+      # @param [String] task_type Task type
+      # @param [String] task_id Task ID
+      # @return [void]
+      def remove_task_from_queue(task_type, task_id)
+        @task_api.remove_task_from_queue(task_type, task_id)
+      end
+
+      # Get queue sizes for task types
+      # @param [Array<String>] task_types List of task types (optional)
+      # @return [Hash<String, Integer>] Map of task type to queue size
+      def get_queue_sizes(task_types: nil)
+        @task_api.size(task_types: task_types)
+      end
+
+      # Get all queue details
+      # @return [Hash<String, Integer>] Map of task type to queue size
+      def get_all_queue_details
+        @task_api.all_queue_details
+      end
+
+      # Get queue details for a specific task type
+      # @param [String] task_type Task type
+      # @return [Hash] Queue details
+      def get_queue_details(task_type)
+        @task_api.get_task_queue_details(task_type)
+      end
+
+      # Add task execution log
+      # @param [String] task_id Task ID
+      # @param [String] log_message Log message
+      # @return [void]
+      def add_task_log(task_id, log_message)
+        @task_api.log(task_id, log_message)
+      end
+
+      # Get task execution logs
+      # @param [String] task_id Task ID
+      # @return [Array<TaskExecLog>] Array of task execution logs
+      def get_task_logs(task_id)
+        @task_api.get_task_logs(task_id)
+      end
+
+      # Get pending tasks for a task type
+      # @param [String] task_type Task type
+      # @param [Integer] start Start index (default: 0)
+      # @param [Integer] count Number of tasks (default: 100)
+      # @return [Array<Task>] Array of pending tasks
+      def get_pending_tasks(task_type, start: 0, count: 100)
+        @task_api.get_pending_task_for_task_type(task_type, start: start, count: count)
+      end
+
+      # Update task by reference name
+      # @param [String] workflow_id Workflow ID
+      # @param [String] task_ref_name Task reference name
+      # @param [String] status New status
+      # @param [Hash] output Task output data (optional)
+      # @param [String] worker_id Worker ID (optional)
+      # @return [String] Updated workflow ID
+      def update_task_by_ref_name(workflow_id, task_ref_name, status, output: nil, worker_id: nil)
+        @task_api.update_task_by_ref_name(workflow_id, task_ref_name, status, output: output, worker_id: worker_id)
+      end
+
+      # Update task by reference name synchronously (returns workflow state)
+      # @param [String] workflow_id Workflow ID
+      # @param [String] task_ref_name Task reference name
+      # @param [String] status New status
+      # @param [Hash] output Task output data (optional)
+      # @param [String] worker_id Worker ID (optional)
+      # @return [Workflow] Updated workflow
+      def update_task_sync(workflow_id, task_ref_name, status, output: nil, worker_id: nil)
+        @task_api.update_task_sync(workflow_id, task_ref_name, status, output: output, worker_id: worker_id)
+      end
+
+      # Get poll data for a task type
+      # @param [String] task_type Task type name
+      # @return [Array<PollData>]
+      def get_task_poll_data(task_type)
+        @task_api.get_poll_data(task_type)
+      end
+
+      # Get all poll data
+      # @return [Array<PollData>]
+      def get_all_poll_data
+        @task_api.get_all_poll_data
+      end
+
+      # Requeue pending tasks
+      # @param [String] task_type Task type name
+      # @return [String]
+      def requeue_pending_task(task_type)
+        @task_api.requeue_pending_task(task_type)
+      end
+
+      # Search for tasks
+      # @param [Integer] start Start index (default: 0)
+      # @param [Integer] size Page size (default: 100)
+      # @param [String] sort Sort order (optional)
+      # @param [String] free_text Free text search (default: '*')
+      # @param [String] query Query string (optional)
+      # @return [SearchResult]
+      def search(start: 0, size: 100, sort: nil, free_text: '*', query: nil)
+        @task_api.search(start: start, size: size, sort: sort, free_text: free_text, query: query)
+      end
+
+      # Get queue sizes for specific task types
+      # @param [Array<String>] task_types List of task type names
+      # @return [Hash<String, Integer>]
+      def get_queue_sizes_for_tasks(task_types)
+        @task_api.get_queue_sizes_for_tasks(task_types)
+      end
+    end
+  end
+end