gem 'yes-core'

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      # Define attributes with types
      attribute :name, :string, command: true # this will generate a change_name command
      attribute :email, :email, command: true # this will generate a change_email command

      attribute :company_id, :uuid # this will not generate a command, just an accessor

      # Define custom commands
      command :assign_to_company do
        payload company_id: :uuid # Payload keys need to match attributes

        guard :company_exists do
          CompanyReadModel.exists?(payload.company_id)
        end
      end
    end
  end
end

# Usage
user = Users::User::Aggregate.new
user.change_name("John Doe")
user.assign_to_company(company_id: "123e4567-e89b-12d3-a456-426614174000")

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      # Basic attributes without commands
      attribute :name, :string
      attribute :email, :email

      # Attributes with change commands
      attribute :age, :integer, command: true
      attribute :bio, :string, command: true
    end
  end
end

module Companies
  module Company
    class Aggregate < Yes::Core::Aggregate
      # Define attributes that will be updated by the command
      attribute :user_ids, :uuids

      command :assign_user do
        # Define payload attributes
        payload user_id: :uuid

        guard :user_not_already_assigned do
          !user_ids.include?(payload.user_id)
        end

        # Custom state update logic
        update_state do
          user_ids { (user_ids || []) + [payload.user_id] }
        end
      end
    end
  end
end

# config/initializers/yes_types.rb
Yes::Core::Types.register(:subscription_type, Yes::Core::Types::String.enum('premium', 'basic'))
Yes::Core::Types.register(:team_role, Yes::Core::Types::String.enum('lead', 'member'))
Yes::Core::Types.register(:training_year, Yes::Core::Types::Coercible::Integer.constrained(gteq: 1, lteq: 4))

attribute :role, :team_role, command: true

user.change_age(30)
user.change_bio("Software developer")

user.change_age(age: 30)

# Valid change
if user.can_change_email?("user@example.com")
  user.change_email("user@example.com")
end

# Invalid change
user.can_change_email?("invalid-email") # => false
user.email_change_error # Contains the error message

command :register_apprenticeship do
  payload title: :string,
          start_date: :date,
          location_id: :uuid
end

command :update_profile do
  # Optional key - attribute can be omitted from payload
  payload phone: { type: :string, optional: true },
          # Nullable value - attribute must be present but can be nil
          max_travel_time: { type: :integer, nullable: true },
          # Both optional key and nullable value
          email: { type: :email, optional: true, nullable: true }
end

command :publish do
  guard :all_required_fields_present do
    title.present? && description.present?
  end

  guard :not_already_published do
    !published
  end
end

command :publish do
  event :apprenticeship_published
end

command :update_contact_info do
  payload email: { type: :email, encrypt: true },
          phone: { type: :phone, encrypt: true },
          address: :string  # not encrypted
end

command :update_sensitive_data do
  payload ssn: :string, email: :email, phone: :phone
  encrypt :ssn, :email, :phone
end

# For simple attribute commands
command :change, :ssn, :string, encrypt: true

command :add_tag do
  payload tag: :string

  update_state do
    tags { (tags || []) + [payload.tag] }
  end
end

update_state do
  name { payload.name }
  email { payload.email }
end

module Companies
  module Company
    class Aggregate < Yes::Core::Aggregate
      # Define attributes that match the payload keys
      attribute :name, :string
      attribute :description, :string

      command :update_details do
        # Payload keys must match attribute names
        payload name: :string,
                description: :string
        # No update_state block needed - automatic update
      end
    end
  end
end

company = Companies::Company::Aggregate.new
company.update_details(name: "Acme Inc", description: "Manufacturing company")
# Both name and description attributes will be updated automatically

module Articles
  module Article
    class Aggregate < Yes::Core::Aggregate
      attribute :title, :string
      attribute :tags, :array
      attribute :status, :string

      command :publish do
        payload title: :string

        update_state do
          # You can reference payload values
          title { payload.title }
          # Or set static values
          status { "published" }
          # Or combine existing data with payload
          tags { (tags || []) + ["published"] }
        end
      end
    end
  end
end

company.assign_user(user_id: "123e4567-e89b-12d3-a456-426614174000")

if company.can_assign_user?(user_id: "123e4567-e89b-12d3-a456-426614174000")
  company.assign_user(user_id: "123e4567-e89b-12d3-a456-426614174000")
else
  puts company.assign_user_error
end

command :change, :age, :integer, localized: true

  attribute :age, :integer, localized: true
  command :change_age do
    payload age: :integer, locale: :locale
    guard(:no_change) { value_changed?(send(attribute_name), payload.send(attribute_name)) }
  end

command :change, :age, :integer do
  payload fantastic_new_age: :integer
  guard(:no_change) { age != payload.fantastic_new_age }
end

command :activate, :dropout, attribute: :dropout_enabled

  attribute :dropout_enabled, :boolean
  command :activate_dropout do
    guard(:no_change) { !dropout_enabled }
    update_state { dropout_enabled { true } }
  end

command [:enable, :disable], :dropout

  attribute :dropout, :boolean
  command :enable_dropout do
    guard(:no_change) { !dropout }
    update_state { dropout { true } }
  end

  command :disable_dropout do
    guard(:no_change) { dropout }
    update_state { dropout { false } }
  end

command :publish

  attribute :published, :boolean
  command :publish do
    guard(:no_change) { !published }
    update_state { published { true } }
  end

attribute :email, :email, command: true do
  guard :check_email_domain do
    payload.email.end_with?('@example.com')
  end
end

command :publish do
  guard :all_required_fields_present do
    title.present? && description.present?
  end

  guard :not_already_published do
    !published
  end
end

command :update_status do
  payload status: :string

  guard :valid_response do
    # Method-style access
    payload.metadata.response_id.present?

    # Hash-style access
    payload.metadata[:response_id].present?
  end

  guard :authorized_user do
    # If a metadata key doesn't exist, nil is returned
    payload.metadata.user_role == 'admin' # returns nil if user_role is not in metadata
  end
end

command :update_profile do
  payload bio: :string

  # Will trigger a no-change transition error if bio hasn't changed
  guard :no_change do
    payload.bio != bio
  end

  # Will trigger an invalid transition error if bio contains prohibited words
  guard :appropriate_content do
    !payload.bio.include?("prohibited content")
  end
end

user = Users::User::Aggregate.new
user.change_name("Jane Doe")
user.name # => "Jane Doe" (reads from the read model)

# For Users::User::Aggregate
# The read model class will be UsersUser
# And the database table will be users_users

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      # Use a custom read model name
      read_model 'custom_user', public: false

      attribute :email, :email, command: true
      attribute :name, :string
    end
  end
end

class UpdateReadModels < ActiveRecord::Migration[7.1]
  def change
    create_table :users do |t|
      t.string :name
      t.string :email
      t.integer :age
      t.integer :revision, null: false, default: -1
      t.timestamps
    end

    add_column :companies, :name, :string
    remove_column :companies, :old_field
  end
end

class AddPendingUpdateTrackingToReadModels < ActiveRecord::Migration[7.1]
  def up
    read_model_tables = Yes::Core.configuration.all_read_model_table_names

    read_model_tables.each do |table_name|
      next unless ActiveRecord::Base.connection.table_exists?(table_name)

      add_column table_name, :pending_update_since, :datetime

      # Unique index to prevent concurrent updates to same aggregate
      add_index table_name, :id,
                unique: true,
                where: 'pending_update_since IS NOT NULL',
                name: truncate_index_name("idx_#{table_name}_one_pending_per_aggregate")

      # Index for efficient recovery queries
      add_index table_name, :pending_update_since,
                where: 'pending_update_since IS NOT NULL',
                name: truncate_index_name("idx_#{table_name}_pending_recovery")
    end
  end
end

# app/jobs/read_model_recovery_job.rb
class ReadModelRecoveryJob < ApplicationJob
  def perform
    Yes::Core::Jobs::ReadModelRecoveryJob.new.perform
  end
end

# Schedule it to run periodically (e.g., every 5 minutes)
# In your scheduler (whenever, sidekiq-cron, etc.):
ReadModelRecoveryJob.perform_later

# Recover a specific read model instance
read_model = UserReadModel.find(id)
Yes::Core::CommandHandling::ReadModelRecoveryService.recover(read_model)

# Recover all stale pending updates (older than 5 minutes by default)
Yes::Core::CommandHandling::ReadModelRecoveryService.recover_all_stale

module Companies
  module Location
    class Aggregate < Yes::Core::Aggregate
      parent :company

      attribute :name, :string, command: true
      attribute :address, :string, command: true
    end
  end
end

parent :company, command: false

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      primary_context :users

      attribute :name, :string, command: true
    end
  end
end

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      removable
    end
  end
end

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      removable(attr_name: :deleted_at)
    end
  end
end

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      removable do
        guard(:published) { published? }
      end
    end
  end
end

module Articles
  module Article
    class Aggregate < Yes::Core::Aggregate
      # Makes aggregate draftable by connecting it to a draft aggregate for managing the draft state.
      # The draft aggregate has to exist already. The default draft aggregate is <CurrentAggregateContext>::<CurrentAggregateName>Draft.
      # Also configures a changes read model (defaults to "<read_model>_change")
      draftable

      # Draftable with custom parameters
      # draftable draft_aggregate: { context: 'ArticleDrafts', aggregate: 'ArticleDraft' }, changes_read_model: :article_change

      attribute :title, :string, command: true
      attribute :content, :string, command: true
    end
  end
end

# Use all defaults
draftable

# Custom context only
draftable draft_aggregate: { context: 'DraftContext' }

# Custom aggregate name only
draftable draft_aggregate: { aggregate: 'MyDraft' }

# Both context and aggregate
draftable draft_aggregate: { context: 'DraftContext', aggregate: 'MyDraft' }

# Custom changes read model only
draftable changes_read_model: :custom_changes

# All custom parameters
draftable draft_aggregate: { context: 'DraftContext', aggregate: 'MyDraft' }, changes_read_model: :my_changes

# config/initializers/yes.rb
Yes::Core.configure do |config|
  config.auth_adapter = MyAuthAdapter.new
end

class MyAuthAdapter
  AuthError = Class.new(Yes::Core::AuthenticationError)

  # @param request [ActionDispatch::Request]
  # @raise [AuthError] if the token is missing or invalid
  # @return [Hash] auth data passed to authorizers as auth_data
  def authenticate(request)
    token = request.headers['Authorization']&.delete_prefix('Bearer ')
    raise AuthError, 'Token missing' unless token

    payload = JWT.decode(token, public_key, true, algorithm: 'RS256').first
    { identity_id: payload['sub'], host: request.host }.merge(payload.symbolize_keys)
  end

  # @param token [String] raw JWT token (extracted from Authorization header)
  # @return [OpenStruct] object with .token returning [decoded_payload_hash]
  def verify_token(token)
    decoded = JWT.decode(token, public_key, true, algorithm: 'RS256')
    OpenStruct.new(token: decoded)
  end

  # @return [Array<Class>] exception classes the controller rescues as 401
  def error_classes
    [AuthError, JWT::DecodeError]
  end

  private

  def public_key
    OpenSSL::PKey::RSA.new(ENV.fetch('JWT_PUBLIC_KEY'))
  end
end

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      # Allow all commands
      authorize do
        true
      end

      attribute :name, :string, command: true
    end
  end
end

authorize do
  # Only allow commands if the authenticated identity matches the user
  command.user_id == auth_data[:identity_id]
end

# First define an aggregate level authorizer
class Aggregate < Yes::Core::Aggregate
  authorize do
    # Base level authorization logic
    auth_data[:identity_id].present?
  end

  # Then add command-specific refinements
  command :publish do
    payload user_id: :uuid

    # Command-specific authorization logic
    authorize do
      # Has access to the command and auth_data
      command.user_id == auth_data[:user_id]
    end
  end
end

Yes::Core.configuration.aggregate_class('Context', 'Aggregate', :publish, :authorizer)

module Users
  module User
    class Aggregate < Yes::Core::Aggregate
      authorize cerbos: true

      attribute :name, :string, command: true
    end
  end
end

module Companies
  module CompanySettings
    class Aggregate < Yes::Core::Aggregate
      # Custom read model and resource name
      authorize cerbos: true,
                read_model_class: CustomCompanySettings,
                resource_name: 'company_settings'

      attribute :name, :string, command: true
    end
  end
end

class CustomCompanySettings < ApplicationRecord
  def auth_attributes
    { company_id: company_id || '' }
  end
end

module Universe
  module Star
    class Aggregate < Yes::Core::Aggregate
      # Base aggregate-level Cerbos authorization
      authorize cerbos: true

      attribute :name, :string, command: true

      # Command with customized Cerbos integration
      command :update_details do
        payload details: :string

        # Command-level authorization with custom Cerbos integration
        authorize do
          # Override resource attributes sent to Cerbos
          resource_attributes { { owner_id: 'test-user-id' } }

          # Override the entire Cerbos payload
          cerbos_payload { { principal: auth_data, resource_id: 'test-id' } }
        end
      end
    end
  end
end

# Gemfile
gem 'yes-command-api'

# config/routes.rb
mount Yes::Command::Api::Engine => '/v1/commands'

# app/contexts/billing/invoice/commands/create/command.rb
module Billing
  module Invoice
    module Commands
      module Create
        class Command < Yes::Core::Command
          attribute :invoice_id, Yes::Core::Types::UUID
          attribute :amount, Yes::Core::Types::Integer
          attribute :currency, Yes::Core::Types::String

          alias aggregate_id invoice_id
        end
      end
    end
  end
end

# app/contexts/billing/invoice/commands/create/handler.rb
module Billing
  module Invoice
    module Commands
      module Create
        class Handler < Yes::Core::Commands::Stateless::Handler
          self.event_name = 'Created'

          def call
            # Add guard logic here, e.g.:
            # no_change_transition('Already exists') if already_exists?

            super # publishes the event
          end
        end
      end
    end
  end
end

# app/contexts/billing/invoice/events/created.rb
module Billing
  module Invoice
    module Events
      class Created < Yes::Core::Event
        def schema
          Dry::Schema.Params do
            required(:invoice_id).value(Yes::Core::Types::UUID)
            required(:amount).value(:integer)
            required(:currency).value(:string)
          end
        end
      end
    end
  end
end

# app/contexts/billing/invoice/commands/authorizer.rb
module Billing
  module Invoice
    module Commands
      class Authorizer < Yes::Core::Authorization::CommandAuthorizer
        def self.call(_command, auth_data)
          raise CommandNotAuthorized, 'Not allowed' unless auth_data[:identity_id].present?
        end
      end
    end
  end
end

# app/contexts/billing/invoice/commands/create/authorizer.rb
module Billing
  module Invoice
    module Commands
      module Create
        class Authorizer < Billing::Invoice::Commands::Authorizer
          # Inherits base authorization; add command-specific checks here
        end
      end
    end
  end
end

Yes::Core.configure do |config|
  config.command_notifier_classes = [
    Yes::Command::Api::Commands::Notifiers::ActionCable,
    Yes::Command::Api::Commands::Notifiers::MessageBus
  ]
end

config.command_notifier_classes = [Yes::Command::Api::Commands::Notifiers::ActionCable]

config.command_notifier_classes = [Yes::Command::Api::Commands::Notifiers::MessageBus]

class SlackNotifier < Yes::Core::Commands::Notifier
  def notify_batch_started(batch_id, transaction = nil, commands = nil)
    # ...
  end

  def notify_batch_finished(batch_id, transaction = nil, responses = nil)
    # ...
  end

  def notify_command_response(cmd_response)
    # ...
  end
end

# Gemfile
gem 'yes-read-api'

# config/routes.rb
mount Yes::Read::Api::Engine => '/queries'

module ReadModels
  module User
    class Filter < Yes::Core::ReadModel::Filter
      has_scope :name do |_controller, scope, value|
        scope.where(name: value)
      end

      has_scope :ids do |_controller, scope, value|
        scope.where(id: value.split(','))
      end

      private

      def read_model_class
        ::UserReadModel
      end
    end
  end
end

module ReadModels
  module User
    class RequestAuthorizer
      def self.call(filter_options, auth_data)
        unless auth_data[:identity_id].present?
          raise Yes::Core::Authorization::ReadRequestAuthorizer::NotAuthorized, 'Not allowed'
        end
      end
    end
  end
end

# lib/tasks/eventstore.rb
subscriptions = Yes::Core::Subscriptions.new

subscriptions.subscribe_to_all(
  MyReadModel::Builder.new,
  { event_types: ['MyContext::SomethingHappened', 'MyContext::SomethingElseHappened'] }
)

subscriptions.start

Yes::Core.configure do |config|
  config.subscriptions_heartbeat_url = ENV['SUBSCRIPTIONS_HEARTBEAT_URL']
  config.subscriptions_heartbeat_interval = 30 # seconds
end

client = Yes::Core::ProcessManagers::ServiceClient.new('media')
# Resolves to MEDIA_SERVICE_URL env var or http://media-cluster-ip-service:3000

client.call(access_token: token, commands_data: [...], channel: '/notifications')

class MyProcessManager < Yes::Core::ProcessManagers::CommandRunner
  def call(event)
    publish(
      client_id: ENV['MY_CLIENT_ID'],
      client_secret: ENV['MY_CLIENT_SECRET'],
      commands_data: build_commands(event)
    )
  end
end

class UserState < Yes::Core::ProcessManagers::State
  RELEVANT_EVENTS = ['Auth::UserCreated', 'Auth::UserNameChanged'].freeze

  attr_reader :name

  private

  def stream
    PgEventstore::Stream.new(context: 'Auth', stream_name: 'User', stream_id: @id)
  end

  def required_attributes
    [:name]
  end

  def apply_user_name_changed(event)
    @name = event.data['name']
  end
end

state = UserState.load(user_id)
state.valid? # true if all required_attributes are present

Yes::Core.configure do |config|
  # Command processing
  config.process_commands_inline = true          # Process commands synchronously (default: true)
  config.command_notifier_classes = []            # Array of notifier classes for command batch notifications

  # Authentication
  config.auth_adapter = nil                      # Auth adapter instance (required for command/read APIs)

  # Cerbos Authorization
  config.cerbos_url = ENV['CERBOS_URL']          # Cerbos server URL (default from env var)
  config.cerbos_principal_data_builder = -> {}    # Lambda to build Cerbos principal data for commands
  config.cerbos_read_principal_data_builder = nil # Lambda for read requests (falls back to above)
  config.cerbos_commands_authorizer_include_metadata = false
  config.cerbos_read_authorizer_include_metadata = false
  config.cerbos_read_authorizer_actions = %w[read]
  config.cerbos_read_authorizer_resource_id_prefix = 'read-'
  config.cerbos_read_authorizer_principal_anonymous_id = 'anonymous'
  config.super_admin_check = ->(_auth_data) { false }

  # Subscriptions
  config.subscriptions_heartbeat_url = nil       # URL to ping for subscription health monitoring
  config.subscriptions_heartbeat_interval = 30   # Heartbeat interval in seconds

  # Observability
  config.otl_tracer = nil                        # OpenTelemetry tracer instance
  config.logger = Rails.logger                   # Logger instance

  # Error reporting
  config.error_reporter = nil                    # Callable for error reporting (e.g. Sentry)
end

user = Test::User::Aggregate.new
user.change_name(name: "John Doe")
user.name # => "John Doe"
TestUser.last.name # => "John Doe"

require 'base64'
user_id = "47330036-7246-40b4-a3c7-7038df508774"
token = Base64.strict_encode64({ identity_id: user_id, user_id: user_id }.to_json)