# ApplesController

def show
  # In-memory example
  apples = [Apple.new(colour: 'red', weight: '1lb'), Apple.new(colour: 'green', weight: '1lb')]
  apple = apples.find { |apple| apple.colour = params[:colour] }

  response_with object: apple, type: :json
end

class Apple
  include Serializable
  attr_accessor :id, :colour, :weight
end

class Apple < Rubee::SequelObject
  attr_accessor :id, :colour, :weight
end

# ApplesController

def show
  apple = Apple.where(colour: params[:colour])&.last

  if apple
    response_with object: apple, type: :json
  else
    response_with object: { error: "apple with colour #{params[:colour]} not found" }, status: 422, type: :json
  end
end

irb(main):015> user = User.new(email: "llo@ok.com", password: 543)
=> #<User:0x000000010cda23b8 @email="llo@ok.com", @password=543>

irb(main):018> user.save
=> true

irb(main):019> user.update(email: "update@email.com")
=> #<User:0x000000010c39b298 @email="update@email.com", @id=3, @password="543", @created="2025-09-28 22:03:07.011332 -0400", @updated="2025-09-28 22:03:07.011332 -0400">

irb(main):016> user.persisted?
=> false

irb(main):011> user = User.last
=> #<User:0x000000010ccea178 @email="ok23@ok.com", @id=2, @password="123", ...>
irb(main):012> user.email = "new@ok.com"
=> "new@ok.com"
irb(main):014> user.reload
=> #<User:0x000000010c488548 @email="ok23@ok.com", @id=2, @password="123", ...> # unpersisted data refreshed from db

irb(main):008> User.last.assign_attributes(email: "bb@ok.com")
=> {"id" => 2, "email" => "ok23@ok.com", "password" => "123"}

irb(main):005> User.where(email: "ok23@ok.com")
=> [#<User:0x000000010cfaa5c0 @email="ok23@ok.com", @id=2, @password="123">]

irb(main):006> User.find_first(email: "ok23@ok.com")
=> #<User:0x000000010cfaa5c0 @email="ok23@ok.com", @id=2, @password="123">

irb(main):007> User.find_last(email: "ok23@ok.com")
=> #<User:0x000000010cfaa5c0 @email="ok23@ok.com", @id=2, @password="123">

irb(main):001> User.all
=> [#<User:0x000000010c239a30 @email="ok@ok.com", @id=1, @password="password", ...>]

irb(main):002> user = User.find 1
=> #<User:0x000000010c2f7cd8 @email="ok@ok.com", @id=1, @password="password", ...>

irb(main):003> User.last
=> #<User:0x000000010c2f7cd8 @email="ok@ok.com", @id=1, @password="password", ...>

irb(main):004> User.create(email: "ok23@ok.com", password: 123)
=> #<User:0x000000010c393818 @email="ok23@ok.com", @id=2, @password=123, ...>

irb(main):021> user.destroy(cascade: true)
=> 1

irb(main):020> user = User.find_or_new(email: "ok23@ok.com")
=> #<User:0x000000010cfaa5c0 @email="ok23@ok.com", @id=2, @password="123">
irb(main):021> user.persisted?
=> true
irb(main):022> user = User.find_or_new(email: "new@ok.com")
=> #<User:0x000000010cfaa5c0 @email="new@ok.com", @id=nil, @password=nil>
irb(main):023> user.persisted?
=> false

irb(main):022> User.destroy_all
=> [#<User ...>, #<User ...>]
irb(main):023> User.all
=> []

# user model
class User < Rubee::SequelObject
  attr_accessor :id, :email, :password, :created, :updated
  owns_many :comments, over: :posts
end

# comment model
class Comment < Rubee::SequelObject
  attr_accessor :id, :text, :user_id, :created, :updated
  owns_many :users, over: :posts
end

# join post model
class Post < Rubee::SequelObject
  attr_accessor :id, :user_id, :comment_id, :created, :updated
  holds :comment
  holds :user
end

irb(main):008> result = Comment.dataset.join(:posts, comment_id: :id)
irb(main):009>  .where(comment_id: Comment.where(text: "test").last.id)
irb(main):010>  .then { |dataset| Comment.serialize(dataset) }
=> [#<Comment:0x0000000121889998 @id=30, @text="test", @user_id=702, ...>]

irb(main):001> Comment.where(text: "test").where(user_id: 1)
=> [#<Comment:0x0000000121889998 @id=30, @text="test", @user_id=702, ...>]

irb(main):001> comments = Comment.all.paginate(page: 1, per_page: 3)

irb(main):001> comments.pagination_meta
=> {:current_page=>1, :per_page=>3, :total_count=>10, :first_page=>true, :last_page=>false, :prev=>nil, :next=>2}

gem 'sqlite3'

Rubee::Configuration.setup(env = :development) do |config|
  config.database_url = { url: 'sqlite://db/development.db', env: }
  ...
end
Rubee::Configuration.setup(env = :test) do |config|
  config.database_url = { url: 'sqlite://db/test.db', env: }
  ...
end
Rubee::Configuration.setup(env = :production) do |config|
  config.database_url = { url: 'sqlite://db/production.db', env: }
  ...
end

gem 'pg'

Rubee::Configuration.setup(env = :development) do |config|
  config.database_url = { url: "postgres://postgres@localhost:5432/development", env: }
  ...
end
Rubee::Configuration.setup(env = :test) do |config|
  config.database_url = { url: "postgres://postgres@localhost:5432/test", env: }
  ...
end
Rubee::Configuration.setup(env = :production) do |config|
  config.database_url = { url: "postgres://postgres:#{ENV['DB_PASSWORD']}@localhost:5432/production", env: }
  ...
end

## configure database write retries
config.db_max_retries    = { env:, value: 3 }     # set to 0 to disable, or increase if needed
config.db_retry_delay    = { env:, value: 0.1 }
config.db_busy_timeout   = { env:, value: 1000 }  # busy timeout in milliseconds before raising an error

Rubee::DBTools.with_retry { User.dataset.insert(email: "test@ok.com", password: "123") }

Rubee::Router.draw do |router|
  router.get     '/posts',       to: 'posts#index'
  router.post    '/posts',       to: 'posts#create'
  router.patch   '/posts/{id}',  to: 'posts#update'
  router.put     '/posts/{id}',  to: 'posts#update'
  router.delete  '/posts/{id}',  to: 'posts#delete'
  router.head    '/posts',       to: 'posts#index'
  router.connect '/posts',       to: 'posts#index'
  router.options '/posts',       to: 'posts#index'
  router.trace   '/posts',       to: 'posts#index'
end

route.{http_method} {path}, to: "{controller}#{action}",
  model: { ...optional }, namespace: { ...optional }, react: { ...optional }

Rubee::Router.draw do |router|
  ...
  router.get "/apples", to: "apples#index",
    model: {
      name: "apple",
      attributes: [
        { name: 'id', type: :primary },
        { name: 'colour', type: :string },
        { name: 'weight', type: :integer },
        { name: 'created', type: :datetime },
        { name: 'updated', type: :datetime },
      ]
    }
end

[
  { name: 'id',              type: :primary },
  { name: 'name',            type: :string },
  { name: 'description',     type: :text },
  { name: 'quantity',        type: :integer },
  { name: 'created',         type: :date },
  { name: 'modified',        type: :datetime },
  { name: 'exists',          type: :time },
  { name: 'active',          type: :boolean },
  { name: 'hash',            type: :bigint },
  { name: 'price',           type: :decimal },
  { name: 'item_id',         type: :foreign_key },
  { name: 'item_id_index',   type: :index },
  { name: 'item_id_unique',  type: :unique }
]

{ name: 'key', type: :string, options: { size: 50, fixed: true } }

String :key, size: 50, fixed: true

router.get "/apples", to: "apples#index"

router.get "/apples", to: "apples#index", model: { name: 'apple' }

router.get "/apples", to: "apples#index",
  model: {
    name: 'apple',
    attributes: [
      { name: 'id', type: :primary },
      { name: 'colour', type: :string },
      { name: 'weight', type: :integer },
      { name: 'created', type: :datetime },
      { name: 'updated', type: :datetime },
    ]
  }

# admin_routes.rb
Rubee::Router.draw do |router|
  router.get '/admin/cabbages', to: 'cabbages#index',
                               model: {
                                 name: 'cabbage',
                                 attributes: [
                                   { name: 'id', type: :primary },
                                   { name: 'name', type: :string },
                                   { name: 'created', type: :datetime },
                                   { name: 'updated', type: :datetime },
                                 ]
                               },
                               namespace: :admin  # mandatory for namespacing support
end

# ./admin/controllers/cabbages_controller.rb
class Admin::CabbagesController < Rubee::BaseController
  def index
    response_with object: Cabbage.all, type: :json
  end
end

# app/controllers/welcome_controller.rb

class WelcomeController < Rubee::BaseController
  def show
    response_with object: { message: 'Hello, world!' }
  end
end

Rubee::Configuration.setup(env = :development) do |config|
  config.database_url = { url: 'sqlite://db/development.db', env: }

  # register React as a view
  config.react = { on: true, env: }
end

# config/routes.rb
Rubee::Router.draw do |router|
  router.get('/', to: 'welcome#show')

  router.get('/api/users', to: 'user#index', react: { view_name: 'users.tsx' })
  # Note: /api/users is the backend endpoint.
  # To render /app/views/users.tsx, update the React routes as shown below.
end

# app/controllers/api/user_controller.rb
class Api::UserController < Rubee::BaseController
  def index
    response_with object: User.all, type: :json
  end
end

class ApplesController < Rubee::BaseController
  before :index, :print_hello                                       # use an instance method as a handler
  after  :index, -> { puts "after index" },  if:     -> { true }   # or use a lambda
  after  :index, -> { puts "after index2" }, unless: -> { false }  # if/unless guards accept a method or lambda
  around :index, :log

  def index
    response_with object: { test: "hooks" }
  end

  def print_hello
    puts "hello!"
  end

  def log
    puts "before log around"
    res = yield
    puts "after log around"
    res
  end
end

class AnyClass
  include Rubee::Hookable
  before :print_world, :print_hello, class_methods: true

  class << self
    def print_world
      puts "world!"
    end

    def print_hello
      puts "hello!"
    end
  end
end

class Foo
  include Rubee::Validatable

  attr_accessor :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  validate do
    attribute(:name).required.type(String).condition(->{ name.length > 2 })

    attribute(:age)
      .required('Age is a mandatory field')
      .type(Integer, error_message: 'Must be an integer!')
      .condition(->{ age > 18 }, fancy_error: 'You must be at least 18 years old!')
  end
end

class User < Rubee::SequelObject
  attr_accessor :id, :email, :password, :created

  validate_after_setters    # runs validation after each setter
  validate_before_persist!  # validates and raises an error if invalid before saving

  validate do
    attribute(:email).required
      .condition(
        ->{ email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i) }, error: 'Wrong email format'
      )
  end
end

Rubee::SequelObject.validate_before_persist!
Rubee::SequelObject.validate_after_setters

# Include all support methods
Rubee::Configuration.setup do |config|
  config.rubee_support = { all: true }
end

# Include only methods for a specific class
Rubee::Configuration.setup do |config|
  config.rubee_support = { classes: [Rubee::Support::String] }
end

# Hash — tolerates string or symbol keys interchangeably
{one: 1}[:one]   # => 1
{one: 1}["one"]  # => 1

# Hash — deep digging
{one: {two: 2}}.deep_dig(:two)  # => 2

# String — enriched with helper methods
"test".pluralize   # => "tests"
"test".singularize # => "test"
"test".camelize    # => "Test"
"TestMe".snakeize  # => "test_me"
"test".singular?   # => true
"test".plural?     # => false

Rubee::Configuration.env
# => :development

Rubee::Configuration.development?
# => true

class UsersController < Rubee::BaseController
  include Rubee::AuthTokenable
  auth_methods :index  # unauthenticated requests to these actions will be rejected

  # GET /users/login
  def edit
    response_with
  end

  # POST /users/login
  def login
    if authenticate!  # initializes @token_header
      response_with type: :redirect, to: "/users", headers: @token_header
    else
      @error = "Wrong email or password"
      response_with render_view: "users_edit"
    end
  end

  # POST /users/logout
  def logout
    unauthenticate!
    response_with type: :redirect, to: "/users/login", headers: @zeroed_token_header
  end

  # GET /users (restricted)
  def index
    response_with object: User.all, type: :json
  end
end

if authenticate! user_model: Client, login: :name, password: :digest_password
  response_with type: :redirect, to: "/clients", headers: @token_header
end

class UsersController < Rubee::BaseController
  include Rubee::AuthTokenable

  REDIRECT_URI  = 'https://mysite.com/users/oauth_callback'
  CLIENT_ID     = ENV['GOOGLE_CLIENT_ID']
  CLIENT_SECRET = ENV['GOOGLE_CLIENT_SECRET']

  # GET /login
  def edit
    response_with
  end

  # POST /users/login
  def login
    if authenticate!
      response_with(type: :redirect, to: "/sections", headers: @token_header)
    else
      @error = "Wrong email or password"
      response_with(render_view: "users_edit")
    end
  end

  # GET /users/oauth_login
  def oauth_login
    response_with(
      type: :redirect,
      to: auth_client.auth_code.authorize_url(
        redirect_uri: REDIRECT_URI,
        scope: 'email profile openid'
      )
    )
  end

  # GET /users/oauth_callback
  def oauth_callback
    code      = params[:code]
    token     = auth_client.auth_code.get_token(code, redirect_uri: REDIRECT_URI)
    user_info = JSON.parse(token.get('https://www.googleapis.com/oauth2/v1/userinfo?alt=json').body)

    user = User.where(email: user_info['email'])&.last
    raise "User with email #{user_info['email']} not found" unless user

    params[:email]    = user_info['email']
    params[:password] = user.password

    if authenticate!
      response_with(type: :redirect, to: "/sections", headers: @token_header)
    else
      @error = "Something went wrong"
      response_with(render_view: "users_edit")
    end
  rescue OAuth2::Error
    @error = "OAuth login failed"
    response_with(render_view: "users_edit")
  rescue StandardError
    @error = "Something went wrong"
    response_with(render_view: "users_edit")
  end

  # POST /users/logout
  def logout
    unauthenticate!
    response_with(type: :redirect, to: "/login", headers: @zeroed_token_header)
  end

  private

  def auth_client
    @client ||= OAuth2::Client.new(
      CLIENT_ID,
      CLIENT_SECRET,
      site:          'https://accounts.google.com',
      authorize_url: '/o/oauth2/auth',
      token_url:     'https://oauth2.googleapis.com/token'
    )
  end
end

gem 'sidekiq'
gem 'rack-session'  # Required for Sidekiq Web UI

# config/base_configuration.rb
Rubee::Configuration.setup(env = :development) do |config|
  config.database_url  = { url: "sqlite://db/development.db", env: }
  config.async_adapter = { async_adapter: Rubee::SidekiqAsync, env: }
end

# inits/sidekiq.rb

# Configure Redis connection
Sidekiq.configure_server do |config|
  config.redis = { url: ENV.fetch('REDIS_URL', 'redis://localhost:6379/0') }
end

Sidekiq.configure_client do |config|
  config.redis = { url: ENV.fetch('REDIS_URL', 'redis://localhost:6379/0') }
end

# Load Rubee application context
unless Object.const_defined?('Rubee')
  require 'rubee'

  # Load environment variables
  require_relative 'dev.rb' if File.exist?(File.join(__dir__, 'dev.rb'))

  # Trigger Rubee autoload
  Rubee::Autoload.call
end

# app/workers/test_async_runner.rb
class TestAsyncRunner
  include Rubee::Asyncable
  include Sidekiq::Worker

  sidekiq_options queue: :default, retry: 3

  def perform(options)
    options = parse_options(options)

    User.create(
      email: options['email'],
      password: options['password']
    )
  end

  private

  def parse_options(options)
    return options unless options.is_a?(String)

    begin
      JSON.parse(options)
    rescue JSON::ParserError
      options
    end
  end
end

# Enqueue job to run asynchronously
TestAsyncRunner.new.perform_async({
  "email" => "new@new.com",
  "password" => "123"
}.to_json)

# Schedule job to run in 5 minutes (300 seconds)
TestAsyncRunner.perform_in(300, {
  "email" => "new@new.com",
  "password" => "123"
})

# inits/middlewares/sidekiq_middleware.rb
require 'sidekiq/web'
require 'rack/session'

class SidekiqMiddleware
  def initialize(app)
    @app = app

    # Get or generate session secret
    session_secret = ENV.fetch('SESSION_SECRET') { generate_secret }

    # Build Sidekiq Web app with authentication
    @sidekiq_app = Rack::Builder.new do
      # Session support (required for CSRF protection)
      use Rack::Session::Cookie,
          secret: session_secret,
          same_site: true,
          max_age: 86400

      # Basic authentication
      use Rack::Auth::Basic, "Sidekiq Dashboard" do |username, password|
        username == ENV.fetch('SIDEKIQ_USERNAME', 'admin') &&
        password == ENV.fetch('SIDEKIQ_PASSWORD', 'password')
      end

      run Sidekiq::Web
    end
  end

  def call(env)
    if env['PATH_INFO'].start_with?('/sidekiq')
      # Route to Sidekiq Web UI
      env['SCRIPT_NAME'] = '/sidekiq'
      env['PATH_INFO'] = env['PATH_INFO'].sub(%r{^/sidekiq}, '') || '/'
      @sidekiq_app.call(env)
    else
      # Pass through to main app
      @app.call(env)
    end
  end

  private

  def generate_secret
    secret_file = '.session.key'

    if File.exist?(secret_file)
      File.read(secret_file).strip
    else
      require 'securerandom'
      secret = SecureRandom.hex(64)
      File.write(secret_file, secret)
      puts "Generated new session secret in #{secret_file}"
      secret
    end
  end
end

# app/workers/email_worker.rb
class EmailWorker
  include Rubee::Asyncable
  include Sidekiq::Worker

  sidekiq_options queue: :mailers, retry: 5

  def perform(options)
    options = parse_options(options)

    Mailer.send_email(
      to: options['email'],
      subject: options['subject'],
      body: options['body']
    )
  end

  private

  def parse_options(options)
    return options unless options.is_a?(String)
    JSON.parse(options) rescue options
  end
end

# Usage
EmailWorker.new.perform_async({
  "email" => "user@example.com",
  "subject" => "Welcome!",
  "body" => "Hello..."
}.to_json)

# app/workers/booking_confirmation_worker.rb
class BookingConfirmationWorker
  include Rubee::Asyncable
  include Sidekiq::Worker

  sidekiq_options queue: :mailers, retry: 3

  def perform(options)
    options = parse_options(options)

    # Fetch records from database
    service = Service.find(options['service_id'])
    time_slot = TimeSlot.find(options['time_slot_id'])

    Mailer.booking_confirmation(
      to: options['to'],
      client_name: options['client_name'],
      service: service,
      time_slot: time_slot
    )
  end

  private

  def parse_options(options)
    return options unless options.is_a?(String)
    JSON.parse(options) rescue options
  end
end

# Usage
BookingConfirmationWorker.new.perform_async({
  "to" => "client@example.com",
  "client_name" => "John Doe",
  "service_id" => 15,
  "time_slot_id" => 91
})

# test_async_runner.rb
class TestAsyncRunner
  include Rubee::Asyncable

  def perform(options)
    User.create(email: options['email'], password: options['password'])
  end
end

TestAsyncRunner.new.perform_async(options: { "email" => "new@new.com", "password" => "123" })

Rubee::Configuration.setup(env = :development) do |config|
  config.database_url = { url: "sqlite://db/development.db", env: }
  config.logger       = { logger: MyLogger, env: }
end

# app/controllers/welcome_controller.rb
class WelcomeController < Rubee::BaseController
  around :show, ->(&target_method) do
    start = Time.now
    Rubee::Logger.warn(message: 'This is a warning message', method: :show, class_name: 'WelcomeController')
    Rubee::Logger.error(message: 'This is an error message', class_name: 'WelcomeController')
    Rubee::Logger.critical(message: 'We are on fire!')
    target_method.call
    Rubee::Logger.info(
      message: "Execution Time: #{Time.now - start} seconds",
      method: :show,
      class_name: 'WelcomeController'
    )
    Rubee::Logger.debug(object: User.last, method: :show, class_name: 'WelcomeController')
  end

  def show
    response_with
  end
end

gem 'ru.Bee'
gem 'redis'
gem 'websocket'

# config/base_configuration.rb
Rubee::Configuration.setup(env = :development) do |config|
  ...
  config.redis_url = { url: "redis://localhost:6378/0", env: }
end

# config/routes.rb
Rubee::Router.draw do |router|
  ...
  router.get('/ws', to: 'users#websocket')
  # On the client: const ws = new WebSocket("ws://website/ws");
end

# app/models/user.rb
class User < Rubee::BaseModel
  include Rubee::PubSub::Publisher
  include Rubee::PubSub::Subscriber
  ...
end

# app/controllers/users_controller.rb
class UsersController < Rubee::BaseController
  attach_websocket!  # handles WebSocket connections and routes them to publish, subscribe, unsubscribe

  # Expected client params: { action: 'subscribe', channel: 'default', id: '123', subscriber: 'User' }
  def subscribe
    channel   = params[:channel]
    sender_id = params[:options][:id]
    io        = params[:options][:io]

    User.sub(channel, sender_id, io) do |channel, args|
      websocket_connections.register(channel, args[:io])
    end
    response_with(object: { type: 'system', channel: params[:channel], status: :subscribed }, type: :websocket)
  rescue StandardError => e
    response_with(object: { type: 'system', error: e.message }, type: :websocket)
  end

  # Expected client params: { action: 'unsubscribe', channel: 'default', id: '123', subscriber: 'User' }
  def unsubscribe
    channel   = params[:channel]
    sender_id = params[:options][:id]
    io        = params[:options][:io]

    User.unsub(channel, sender_id, io) do |channel, args|
      websocket_connections.remove(channel, args[:io])
    end
    response_with(object: params.merge(type: 'system', status: :unsubscribed), type: :websocket)
  rescue StandardError => e
    response_with(object: { type: 'system', error: e.message }, type: :websocket)
  end

  # Expected client params: { action: 'publish', channel: 'default', message: 'Hello', id: '123', subscriber: 'User' }
  def publish
    args = {}
    User.pub(params[:channel], message: params[:message]) do |channel|
      user               = User.find(params[:options][:id])
      args[:message]     = params[:message]
      args[:sender]      = params[:options][:id]
      args[:sender_name] = user.email
      websocket_connections.stream(channel, args)
    end
    response_with(object: { type: 'system', message: params[:message], status: :published }, type: :websocket)
  rescue StandardError => e
    response_with(object: { type: 'system', error: e.message }, type: :websocket)
  end
end

# app/inits/middlewares/my_middleware.rb
class MyMiddleware
  def initialize(app)
    @app = app
  end

  def call(env)
    Logger.info("Middleware called")
    @app.call(env)
  end
end

# config/base_configuration.rb
require_relative 'inits/middlewares/my_middleware'

config.middlewares = { middlewares: [MyMiddleware], env: }