on_strum-service - Abstract class for service object scaffolding

gem 'on_strum-service'

require 'on_strum/service'

class MyService
  include OnStrum::Service

  def call
    # Your service logic here
    output(result) # Use output to return successful result
  end
end

# Call with context hash
MyService.call(input_hash) do |monad|
  monad.success { |result| puts "Success: #{result}" }
  monad.failure { |errors| puts "Errors: #{errors}" }
end

# Call with only keyword arguments
MyService.call(name: 'John', age: 42) do |monad|
  monad.success { |result| puts "Success: #{result}" }
  monad.failure { |errors| puts "Errors: #{errors}" }
end

# Call with both context and keyword arguments
MyService.call(input_hash, name: 'John', age: 42) do |monad|
  monad.success { |result| puts "Success: #{result}" }
  monad.failure { |errors| puts "Errors: #{errors}" }
end

MyService.call(context, **config) # Please note that the context is optional and defaults to an empty hash

class DocumentProcessor
  include OnStrum::Service
  
  def call
    # Working with the main data context
    validate_metadata(metadata)
    process_content(content)
  end
end

# Processing a document with its data
DocumentProcessor.call({
  content: 'Some text content',
  metadata: { author: 'John', date: '2024-03-20' }
})

# Or with no context when not needed
DocumentProcessor.call # Uses default empty hash

class DocumentProcessor
  include OnStrum::Service
  
  def call
    return if skip_processing
    
    process_content(
      content,
      format: output_format,    # from config
      compress: compress_output # from config
    )
  end
end

# Configuring the processing behavior
DocumentProcessor.call(
  { content: 'Raw content' },           # Context: What to process
  output_format: :pdf,                  # Config: How to process
  compress_output: true,
  skip_processing: false
)

service = DocumentProcessor.call(
  { format: 'html' },          # Context format
  format: 'pdf'                # Config format - takes precedence
)
# Inside service:
# format => 'pdf'
# input_snapshot[:format] => 'html'

class UserService
  include OnStrum::Service

  def call
    # Case 1: Default success output
    output('Default result')  # or output(:default, 'Default result')

    # Case 2: Named success output
    output(:user, { id: 1, name: 'John' })
    
    # Case 3: Multiple named outputs
    output(:stats, { count: 42 })
    output(:status, 'completed')

    # Error cases
    add_error(:validation, :invalid_format)  # Will trigger failure(:validation) handler
    add_error(:auth, :unauthorized)          # Will trigger failure(:auth) handler
  end
end

# Handling different success and failure scenarios
UserService.call(data) do |monad|
  # Success handlers
  monad.success { |result| puts "Default handler: #{result}" }
  monad.success(:user) { |user| puts "User handler: #{user}" }
  monad.success(:stats) { |stats| puts "Stats handler: #{stats}" }

  # Failure handlers
  monad.failure { |errors| puts "Default error handler: #{errors}" }
  monad.failure(:validation) { |errors| puts "Validation errors: #{errors}" }
  monad.failure(:auth) { |errors| puts "Auth errors: #{errors}" }
end

service.call do |monad|
  # These can be defined in any order
  monad.success(:specific) { |value| puts "Specific: #{value}" }
  monad.success { |value| puts "Default: #{value}" }
end

service.call do |monad|
  # These can be defined in any order
  monad.failure(:not_found) { |errors| puts "Not found: #{errors}" }
  monad.failure(:validation) { |errors| puts "Validation: #{errors}" }
  monad.failure { |errors| puts "Default error: #{errors}" }
end

class ProcessingService
  include OnStrum::Service

  def call
    # Set multiple outputs
    output(:step1, "First step done")
    output(:step2, "Second step done")
    output(:final, "All completed")

    # The last output becomes the default result
    # unless a specific handler is matched
  end
end

ProcessingService.call do |monad|
  monad.success(:step1) { |result| puts "Step 1: #{result}" }
  monad.success(:step2) { |result| puts "Step 2: #{result}" }
  monad.success(:final) { |result| puts "Final: #{result}" }
  monad.success { |result| puts "Default: #{result}" } # Gets :final result
end

class ValidationService
  include OnStrum::Service
  
  def call
    # Add single error
    add_error(:email, :invalid)

    # Add multiple errors for one key
    add_error(:password, :too_short)
    add_error(:password, :no_special_chars)

    # Add multiple errors at once
    # You can use bang (!) methods to immediately exit the service with errors
    add_errors!(
      email: %i[invalid taken],
      password: %i[too_short no_special_chars]
    )
  end
end

class UserService
  include OnStrum::Service

  def call
    # Validate required fields
    required!(:email)    # Will exit immediately if email is missing
    required(:password)  # Will add error but continue execution

    # Your logic here
  end

  # Also you can use audit method for prevalidations
  def audit
    required(:email)
    required(:password)
    # something else...
  end
end

class ProcessingService
  include OnStrum::Service

  def call
    # Trigger hooks during processing
    hook(:processing_started)
    # ... do work ...
    hook(:processing_completed, result)
    output(result)
  end
end

# Handle hooks in the caller
ProcessingService.call(data) do |monad|
  monad.on(:processing_started) { puts 'Started!' }
  monad.on(:processing_completed) { |data| puts "Completed with: #{data}" }
  monad.success { |value| puts "Final result: #{value}" }
end

class DataService
  include OnStrum::Service

  def call
    # Slice specific keys from input
    sliced(:name, :email)  # Reduces input to only these keys

    # Check if any of specified keys exist
    any(:email, :phone)    # Ensures at least one exists

    # Process array of hashes
    sliced_list(:name, :email) # Slices each hash in array
  end
end

# Example of error handling with sliced_list
class ArrayProcessor
  include OnStrum::Service

  def call
    # This will fail if input is not an array
    sliced_list(:name, :email)
    output(input)
  end
end

# This will fail because input is not an array
ArrayProcessor.call({ some: 'hash' }) do |monad|
  monad.failure do |errors|
    errors # => { input: [:must_be_array] }
  end
end

# This will fail because one of items is not a hash
ArrayProcessor.call([{ name: 'John' }, 'not a hash']) do |monad|
  monad.failure do |errors|
    errors # => { input_subitem: [:must_be_hash] }
  end
end

# This will succeed and process only specified keys
ArrayProcessor.call([
  { name: 'John', email: 'john@example.com', age: 30 },
  { name: 'Jane', email: 'jane@example.com', phone: '123' }
]) do |monad|
  monad.success do |processed_array|
    processed_array # => [
      # Only name and email keys are preserved
      { name: 'John', email: 'john@example.com' },
      { name: 'Jane', email: 'jane@example.com' }
    ]
  end
end

class GreetingService
  include OnStrum::Service

  def call
    # 'name' will be looked up from:
    # 1. Input hash (if it's a Hash)
    # 2. Keyword arguments
    # Supports both string and symbol keys
    output("Hello, #{name}!")
  end
end

# Using input hash (context)
GreetingService.call({ name: 'John' })

# Using keyword arguments (config)
GreetingService.call({}, name: 'John')

# Mixed usage (keyword args take precedence)
GreetingService.call({ name: 'John' }, name: 'Jane')  # Will use 'Jane'

# Supports both string and symbol keys
GreetingService.call({ 'name' => 'John' })  # Works, passing context as hash with string key
GreetingService.call('name' => 'John')      # Works, passing keyword arguments with string key
GreetingService.call({ name: 'John' })      # Works, passing context as hash with symbol key
GreetingService.call(name: 'John')          # Works, passing keyword arguments with symbol key