GR API Manager

gem 'gr_api_manager', '~> 0.4.0'

require 'gr_api_manager'

# Initialize the server with static token and JWT key
api = GRApiManager::Server.new(
  port: 4000,
  bearer_token: "my_static_secret_token",
  jwt_secret: "my_jwt_signing_secret"
)

# Public endpoint (no auth required)
api.get('/health', auth: false) do
  { status: 'online', timestamp: Time.now.to_i }
end

# Protected endpoint with static token (default: auth = true)
api.get('/protected-data') do
  { message: "Access granted with Bearer Token", data: [10, 20, 30] }
end

# Start the server
api.run!

api = GRApiManager::Server.new(
  bearer_token: "my_secret_company_token_2026"
)

# Public route
api.get('/public', auth: false) do
  { status: "open access" }
end

# Protected routes (default auth: true)
api.get('/admin/config') do
  { database: "connected", environment: "production" }
end

api.post('/admin/restart', requires: [:reason]) do |params|
  { action: "restarting", reason: params[:reason] }
end

api = GRApiManager::Server.new(
  jwt_secret: "my_super_secret_jwt_key"
)

# 1. Login: issue and return token
api.post('/auth/login', auth: false, requires: { email: :email, password: String }) do |params|
  if params[:email] == "admin@company.com" && params[:password] == "pass123"
    token = api.jwt_encode(
      { user_id: 42, email: params[:email], role: "admin" },
      exp: Time.now.to_i + 3600 # 1-hour expiration
    )
    { token: token, token_type: "Bearer", expires_in: 3600 }
  else
    status 401
    { error: "Invalid credentials" }
  end
end

# 2. JWT-protected route: automatically injects params[:current_user]
api.get('/profile', auth: :jwt) do |params|
  user = params[:current_user]
  {
    message: "Valid JWT token",
    user_id: user[:user_id],
    email: user[:email],
    role: user[:role]
  }
end

module AuthRoutes
  def self.setup(router, api_server)
    router.post('/login', auth: false, requires: { email: :email, password: String }) do |params|
      if params[:email] == "admin@company.com" && params[:password] == "secret"
        token = api_server.jwt_encode({ user_id: 1, email: params[:email], role: "admin" })
        { token: token }
      else
        status 401
        { error: "Invalid credentials" }
      end
    end
  end
end

module AdminRoutes
  def self.setup(router)
    router.get('/metrics') do |params|
      { cpu: "12%", memory: "380MB", user: params[:current_user][:email] }
    end

    router.delete('/users/:id') do |params|
      { message: "User #{params[:id]} deleted" }
    end
  end
end

module FilesRoutes
  def self.setup(router)
    router.post('/upload', requires: [:title]) do |params|
      file = params[:_files][:document]
      path = file.save_to("./storage/#{params[:title]}#{file.extension}")
      { status: "saved", path: path, size: file.size }
    end
  end
end

require 'gr_api_manager'

# Require modular route files
require_relative 'routes/auth_routes'
require_relative 'routes/admin_routes'
require_relative 'routes/files_routes'

api = GRApiManager::Server.new(
  port: 4000,
  jwt_secret: ENV['JWT_SECRET'] || "default_jwt_secret",
  bearer_token: ENV['API_TOKEN'] || "global_static_token"
)

# Root route
api.get('/', auth: false) { { service: "Core API v1.0" } }

# Mount route groups
api.group('/auth') { |g| AuthRoutes.setup(g, api) }
api.group('/admin', auth: :jwt) { |g| AdminRoutes.setup(g) }
api.group('/files', auth: true) { |g| FilesRoutes.setup(g) }

api.run!(workers: 2, threads: '2:8')

api = GRApiManager::Server.new(prefix: '/api/v1')

# 1. LIST (GET) - with auto-cast query parameters
api.get('/products', auth: false) do |params|
  page   = params[:page] || 1        # Integer
  limit  = params[:limit] || 10      # Integer
  active = params[:active] != false  # Boolean
  
  {
    page: page,
    limit: limit,
    items: [
      { id: 1, name: "Mechanical Keyboard", price: 89.99, active: true },
      { id: 2, name: "4K Monitor", price: 299.99, active: true }
    ]
  }
end

# 2. GET BY ID (GET)
api.get('/products/:id', auth: false) do |params|
  id = params[:id] # Auto Integer
  { id: id, name: "Product #{id}", price: 49.99 }
end

# 3. CREATE (POST) - with strong type validation
api.post('/products', requires: { name: String, price: Float, category: ['tech', 'office'] }) do |params|
  status 201
  {
    message: "Product created",
    product: { id: rand(100..999), name: params[:name], price: params[:price] }
  }
end

# 4. FULL UPDATE (PUT)
api.put('/products/:id', requires: { name: String, price: Float }) do |params|
  {
    message: "Product #{params[:id]} completely updated",
    data: params
  }
end

# 5. PARTIAL UPDATE (PATCH)
api.patch('/products/:id') do |params|
  {
    message: "Updated fields for product #{params[:id]}",
    changes: params.except(:id)
  }
end

# 6. DELETE (DELETE)
api.delete('/products/:id') do |params|
  { message: "Product #{params[:id]} deleted successfully" }
end

api.post '/catalog', requires: {
  sku:         /^[A-Z]{3}-\d{4}$/,           # Regexp: e.g. "PRO-1234"
  title:       String,                       # Non-empty string
  price:       Float,                        # Float number
  stock:       Integer,                      # Integer
  active:      :boolean,                     # true or false
  category:    ['electronics', 'home'],      # Enum / List of allowed values
  photo:       :file,                        # Uploaded FilePayload
  website:     :url,                         # Valid URL (http/https)
  contact:     :email,                       # Valid email address
  discount:    ->(v) { v.to_f.between?(0, 100) } # Custom Lambda validation
} do |params|
  status 201
  { status: "ok", item: params[:title] }
end

api.post('/profile/avatar', requires: [:user_id]) do |params|
  avatar = params[:_files][:avatar] # FilePayload instance

  # Save to disk (creates directories automatically if missing)
  saved_path = avatar.save_to("./storage/avatars/user_#{params[:user_id]}#{avatar.extension}")

  {
    message: "Avatar saved",
    filename: avatar.filename,
    size: avatar.size,
    extension: avatar.extension,
    saved_path: saved_path
  }
end

api.post('/documents/raw') do |params|
  file = params[:_raw_binary] # FilePayload instance

  file.save_to("./storage/docs/#{file.filename}")
  
  {
    format: "raw binary",
    detected_filename: file.filename,
    size_bytes: file.size,
    mime_type: file.content_type,
    initial_hex: file.to_hex[0..30]
  }
end

api.post('/files/convert') do |params|
  file = params[:_files][:file]

  {
    base64: file.to_base64, # Clean Base64 string without newlines
    hexadecimal: file.to_hex, # Lowercase hex string
    total_bytes: file.size
  }
end

api.post('/logs/text') do |params|
  raw_text = params[:_raw_text] # UTF-8 String
  { lines: raw_text.lines.count, characters: raw_text.length }
end

api.get('/downloads/photo/:id', auth: false) do |params|
  photo_path = "./storage/avatars/user_#{params[:id]}.jpg"
  
  unless File.exist?(photo_path)
    status 404
    next { error: "Photo not found" }
  end

  # Configure response headers
  content_type 'image/jpeg'
  headers 'Content-Disposition' => "inline; filename=\"photo_#{params[:id]}.jpg\""
  
  # Return binary bytes directly
  File.binread(photo_path)
end

api = GRApiManager::Server.new(
  rate_limit:          60,   # Max 60 requests
  rate_limit_window:   60,   # per 60-second window
  trust_proxy_headers: true  # Reads CF-Connecting-IP, X-Real-IP, X-Forwarded-For
)

api.get('/analytics') do |params|
  # Request: /analytics?id=123&active=true&discount=15.5&balance=-500&category=tech
  
  params[:id]        # => 123 (Integer)
  params[:active]    # => true (TrueClass)
  params[:discount] # => 15.5 (Float)
  params[:balance]   # => -500 (Integer)
  params[:category]  # => "tech" (String)
  
  { status: "ok" }
end

api.post('/resources') do
  status 201 # Created
  { message: "Resource created" }
end

api = GRApiManager::Server.new(dev_mode: true)

# Start with 4 worker processes and 4:16 threads per worker
api.run!(workers: 4, threads: '4:16')