rsodx 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9530a9b38e69fdae2f3eee74634ab298aabf3fa11df94d5e28dffd46e7fbffed
-  data.tar.gz: 45db9f15c1a2fbee0d2047373c2958ac913fa262e1833ba9c07b925d76f2577e
+  metadata.gz: 74be3af36e2f6319995f69ec786e1067923306f658d57147902cbaca1e285387
+  data.tar.gz: 8434da27ab813e8b757f4d5a3c6acc71cf9b9522987aea52b119c97aa8dcfda6
 SHA512:
-  metadata.gz: 2074732db6099bd5681845ed895d5679e9b33b5aea3fe5a8a83d767ac47dbc670d86511d330599b79e940ae51797a6c9d77861dff8472082ec8806d4c9f07c9b
-  data.tar.gz: eb6590b94d33281d0d179a9c6cb62b1c70fef8115c8b8486e230f21154672cdf618ed37738b1fe1d6e918fa60282d5e98c27cec1b5a41dfe56226002661b4d2b
+  metadata.gz: 40244cd860d2e0e3f9010a2abca202c3c4f87720b2f99122071c240330e9d54ad82398c0f78fef94388ed6336dbdd162c0956bb24ba847c5270966488539b21a
+  data.tar.gz: 72f2e95d4a9ed42bbe82f3c013471a9b3aa4789568013dcb038edf9e514249e2b06591cfa99be7c14408c1a6f7b5bded9fa99118cfbaf430157bc37568d990d3

data/README.md

@@ -1,21 +1,37 @@
 # Rsodx
 
-> Add Rsodx and just code ✨
+<p align="left">
+  <img src="docs/banner.jpg" width="300px" alt="Rsodx banner">
+</p>
+
+`rsodx` is a minimal, modular framework for building fast and maintainable Ruby microservices.  
+Inspired by the best of Rails, Sinatra, and Sequel — it gives you just enough structure to scale, without the overhead.
+
+No magic. Just clean code and powerful tools.
+
+
+```bash
+$ rsodx new my_rail_company
+🛤️  Initializing Transport Empire...
+📦 Creating folders...
+✅ Done! Start building your microservice railway!
+```
 
-Rsodx is a lightweight, modular microservice framework for Ruby — designed to be fast, clean, and scalable. It provides a minimal architecture inspired by Rails, Sinatra, and Sequel, allowing you to focus on writing business logic without boilerplate.
 
 ---
 
 ## 🧠 Philosophy
 
-- No monoliths — build small services
-- No magic — just plain Ruby
-- No opinionated ORM or router — just simple tools
-- Easily extendable and production-ready
+- **Micro-first** — focus on small, single-purpose services
+- **Explicit over implicit** — no hidden behavior, no global state
+- **Modular by design** — include only what you need
+- **Ruby-native** — use familiar patterns, no learning curve
+- **Production-oriented** — simple to develop, easy to deploy
 
 ---
 
-Вот аккуратно оформленный раздел `Installation` для твоего README:
+> ✅ `rsodx` includes routing, interactors, validation, and service structure —  
+all wrapped into a fast and lightweight toolkit made for modern Ruby apps.
 
 ---
 
@@ -39,84 +55,195 @@ bundle add rsodx
 gem install rsodx
 ```
 
-> ✅ `rsodx` is designed for microservice architecture and includes routing, interactors, validation, and more — all in one lightweight package.
+---
+
+## 🚀 CLI Commands
+
+`rsodx` ships with a powerful and lightweight CLI tool for generating services and scaffolding applications.
+
+You can run CLI commands via:
+
+```bash
+bin/rsodx [command] [args]
+```
 
 ---
 
+## 🔧 Generators
 
-## 📦 Project Structure
+Generate various application components using simple commands:
 
-```text
-my_service/
+```bash
+bin/rsodx generate controller v1/users/index
+bin/rsodx generate presenter v1/users/index
+bin/rsodx generate serializer v1/users/index
+```
+
+Or using aliases:
+
+```bash
+bin/rsodx g controller v1/users/index
+```
+
+To generate **all three** at once (controller, presenter, serializer):
+
+```bash
+bin/rsodx g action v1/users/index
+```
+
+This creates:
+
+- `app/controllers/v1/users/index_controller.rb`
+- `app/presenters/v1/users/index_presenter.rb`
+- `app/serializers/v1/users/index_serializer.rb`
+
+---
+
+## 🛠 Scaffold New App
+
+Create a full Rsodx project with:
+
+```bash
+bin/rsodx new my_app
+```
+
+Or using alias:
+
+```bash
+bin/rsodx n my_app
+```
+
+This will create a new directory `my_app` with:
+
+- `Gemfile`, `.env`, `.ruby-version`
+- `config.ru`, `Rakefile`, environment loader
+- `app/` structure (`controllers`, `services`, etc.)
+- `bin/console` and `bin/rsodx` CLI entrypoints
+
+It will be immediately runnable:
+
+```bash
+cd my_app
+bundle install
+bin/rsodx server
+```
+
+---
+
+## 🌐 Server Command
+
+Run a local Rack-based Puma server:
+
+```bash
+bin/rsodx server
+```
+
+Available options:
+
+- `--port=PORT` – default: `9292`
+- `--env=ENV` – default: `development`
+
+Example:
+
+```bash
+bin/rsodx server --port=3000 --env=production
+```
+
+### 🔍 How it works
+
+This command launches Puma via `rackup`:
+
+```ruby
+pid = spawn("bundle exec rackup --port=#{port} --host=0.0.0.0")
+Process.wait(pid)
+```
+
+It ensures that your `config.ru` is used correctly and delegates the full startup to Rack.
+
+---
+
+## ✅ Command Summary
+
+| Command | Description |
+|--------|-------------|
+| `rsodx new NAME` | Scaffold a new Rsodx project |
+| `rsodx server` | Run the Rack/Puma development server |
+| `rsodx generate controller PATH` | Generate a controller |
+| `rsodx generate presenter PATH` | Generate a presenter |
+| `rsodx generate serializer PATH` | Generate a serializer |
+| `rsodx generate action PATH` | Generate controller + presenter + serializer |
+| Aliases: `g`, `n`, `s` | All commands support short versions |
+
+---
+
+## 📁 Folder Structure (Generated App)
+
+```
+my_app/
 ├── app/
-│   ├── api/
-│   ├── interactors/
-│   ├── models/
+│   ├── controllers/
 │   ├── presenters/
 │   ├── serializers/
-│   ├── app.rb
-│   └── router.rb
+│   ├── services/
+├── bin/
+│   ├── console
+│   └── rsodx
 ├── config/
 │   ├── environment.rb
-│   ├── environments/
-│   └── initializers/
+│   └── environments/
 ├── db/
 │   └── migrations/
-├── bin/
-│   └── console
-├── .env
+├── spec/
 ├── config.ru
+├── .env
 ├── Gemfile
 └── Rakefile
 ```
 
 ---
 
-## 🧰 CLI Commands
+## 🗄️ PostgreSQL Setup
 
-### Create new service
+Your application connects to PostgreSQL using the `DATABASE_URL` defined in `.env`:
 
-```bash
-rsodx new my_service
+```
+DATABASE_URL=postgres://rsodx:paSs4321@localhost:5432/rsodx_development
 ```
 
----
+### 📌 To create this database manually:
 
-### Generate interactor
+1. Open your terminal and run the PostgreSQL client:
 
 ```bash
-bin/rsodx generate interactor CreateUser
+psql -U postgres
 ```
-Creates `app/interactors/create_user.rb`:
 
-```ruby
-class CreateUser < Rsodx::Interactor
-  def call
-    # business logic here
-  end
-end
+2. Then, execute the following SQL commands:
+
+```sql
+-- Create the user
+CREATE USER rsodx WITH PASSWORD 'paSs4321';
+
+-- Create the database
+CREATE DATABASE rsodx_development;
+
+-- Grant privileges
+GRANT ALL PRIVILEGES ON DATABASE rsodx_development TO rsodx;
 ```
 
+> 📍 If your system uses a different PostgreSQL superuser, adjust `-U postgres` accordingly.
+
 ---
 
-### Generate migration
+## ✅ Quick Check
+
+You can test the connection:
 
 ```bash
-bin/rsodx generate migration CreateUsers
+psql postgres://rsodx:paSs4321@localhost:5432/rsodx_development
 ```
-Creates `db/migrations/20240413_create_users.rb`:
 
-```ruby
-Sequel.migration do
-  change do
-    # create_table :users do
-    #   primary_key :id
-    #   String :email
-    #   DateTime :created_at
-    # end
-  end
-end
-```
+If it connects successfully, your database is ready for development!
 
 ---
 
@@ -125,7 +252,7 @@ end
 ```ruby
 class Router < Rsodx::Router
   namespace "/v1" do
-    post "/users", CreateUsers
+    post "/users", V1::Users::Create
   end
 end
 ```
@@ -168,11 +295,48 @@ CreateUser.call(params: {...})
 
 ---
 
-## 🔜 Roadmap
-- Generator for models, serializers, presenters
-- HTTP + JSON helpers
-- Authentication middleware
-- Better documentation site
+## 🛣️ Roadmap
+
+Planned features and improvements for upcoming versions of `rsodx`.
+
+### 🔄 Inter-service Communication
+
+- ✅ **Add RabbitMQ support** for event-driven microservices
+    - CLI: `rsodx g subscriber user/created`
+    - DSL: `on_event "user.created", with: HandleUserCreated`
+
+### 🐳 Docker Support
+
+- ✅ Dockerfile and docker-compose.yml templates
+- PostgreSQL, RabbitMQ, App
+
+### 📦 Generators & Tooling
+
+- [ ] `rsodx g worker fetch_data`
+- [ ] `rsodx g subscriber event_name`
+- [ ] CLI flags: `--dry-run`, `--force`, `--skip`
+- [ ] Generate test stubs with each component
+
+### 🌐 Web Server Improvements
+
+- [ ] Auto-discovery of config.ru or App class
+- [ ] `rsodx server --daemon`, `--log`
+
+### 📚 Documentation & API
+
+- [ ] Auto-generate OpenAPI / Swagger docs from declared routes and schemas
+- [ ] DRY validation + schema → Swagger with types and examples
+- [ ] `rsodx g docs` or `rsodx docs generate`
+
+### 🛠 Developer Experience
+
+- [ ] `rsodx console` (IRB + app preload)
+- [ ] `rsodx doctor` for environment diagnostics
+- [ ] Starter project templates (`--template=api`, `--template=evented`)
+
+---
+
+If you’d like to contribute or suggest new features — feel free to open an issue or PR. Let’s make `rsodx` fast, lean and production-ready together! ❤️
 
 ---
 

data/bin/console

@@ -3,10 +3,12 @@
 
 require "bundler/setup"
 require "rsodx"
-require_relative '../lib/config/environment'
+puts Rsodx::LOGO
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+def reload!
+  puts "♻️  Reloading lib/rsodx..."
+  load File.expand_path("../lib/rsodx.rb", __dir__)
+end
 
 require "irb"
-IRB.start(__FILE__)
+IRB.start

data/bin/rsodx

@@ -1,9 +1,6 @@
 #!/usr/bin/env ruby
 
-require "fileutils"
-require "optparse"
-require "rsodx"
+require_relative "../lib/rsodx"
 
-if __FILE__ == $0
-  Rsodx::Cli::Handler.run
-end
+Rsodx::Cli.setup!
+Rsodx::CLI.call

data/lib/rsodx/action.rb

@@ -0,0 +1,63 @@
+module Rsodx
+  class Action < Rsodx::Service
+    delegate :request, :options, :handler_class, to: :context
+
+    before do
+      context.options ||= {}
+      raise "Missing handler_class in context" unless context.handler_class
+    end
+
+    def call
+      run_handler
+    rescue StandardError => e
+      handle_exception(e)
+    end
+
+    private
+
+    def run_handler
+      result = context.handler_class.call(
+        options.merge(request: request, params: request.params)
+      )
+
+      return error_result(result) if result.failure?
+
+      serializer = resolve_serializer
+      serialized = serializer.call(object: result.object)
+      return error_result(serialized) if serialized.failure?
+
+      if presenter_class
+        context.json_response = presenter_class.new(serialized.dto).call
+      elsif request.request_method == 'POST'
+        context.code = 201
+      else
+        context.code = 204
+      end
+    end
+
+    def resolve_serializer
+      from_handler_with_suffix("Serializer") || AppSerializer
+    end
+
+    def presenter_class
+      from_handler_with_suffix("Presenter")
+    end
+
+    def from_handler_with_suffix(suffix)
+      klass_name = handler_class.name.sub(/Controller$/, suffix)
+      Object.const_get(klass_name)
+    rescue NameError
+      nil
+    end
+
+    def error_result(result)
+      code = result.error_code || 500
+      error = result.error || 'Unknown error'
+      halt(code, error)
+    end
+
+    def handle_exception(e)
+      halt(500, e.message)
+    end
+  end
+end

data/lib/rsodx/boot.rb

@@ -1,9 +1,10 @@
 module Rsodx
   module Boot
     def self.load_app_structure(app_root)
-      %w[models interactors presenters serializers api].each do |folder|
+      %w[models controllers services serializers presenters].each do |folder|
         path = File.join(app_root, "app", folder)
         $LOAD_PATH.unshift(path) if Dir.exist?(path)
+        Dir["#{path}/*.rb"].sort.each { |file| require file }
         Dir["#{path}/**/*.rb"].sort.each { |file| require file }
       end
     end

data/lib/rsodx/cli/cli.rb

@@ -0,0 +1,56 @@
+require "dry/cli"
+
+module Rsodx::Cli
+  module Commands
+  end
+  module Commands::Generators
+  end
+
+  extend Dry::CLI::Registry
+
+  def self.setup!
+    register_commands_with_alias(
+      group: "",
+      alias_prefix: "",
+      commands: {
+        "new" => ::Rsodx::Cli::Commands::Scaffold,
+        "n"   => ::Rsodx::Cli::Commands::Scaffold
+      }
+    )
+
+    register_commands_with_alias(
+      group: "generate",
+      alias_prefix: "g",
+      commands: {
+        "migration" => ::Rsodx::Cli::Commands::Generators::Migration,
+        "controller" => ::Rsodx::Cli::Commands::Generators::Controller,
+        "presenter"  => ::Rsodx::Cli::Commands::Generators::Presenter,
+        "serializer" => ::Rsodx::Cli::Commands::Generators::Serializer,
+        "action"     => ::Rsodx::Cli::Commands::Generators::Action
+      }
+    )
+
+    register_commands_with_alias(
+      group: "",
+      alias_prefix: "",
+      commands: {
+        "server" => ::Rsodx::Cli::Commands::Server,
+        "s"      => ::Rsodx::Cli::Commands::Server
+      }
+    )
+  end
+
+  def self.register_commands_with_alias(group:, alias_prefix:, commands:)
+    commands.each do |name, klass|
+      full_name = group && !group.empty? ? "#{group} #{name}" : name
+      alias_name = alias_prefix && !alias_prefix.empty? ? "#{alias_prefix} #{name}" : name
+
+      register full_name.strip, klass
+      register alias_name.strip, klass
+    end
+  end
+end
+
+module Rsodx
+  CLI = Dry::CLI.new(::Rsodx::Cli)
+end

data/lib/rsodx/cli/commands/generator.rb

@@ -0,0 +1,60 @@
+require "fileutils"
+
+module Rsodx::Cli
+  class Generator
+    ROOT_MAP = {
+      controller: "app/controllers",
+      presenter:  "app/presenters",
+      serializer: "app/serializers"
+    }
+
+    SUFFIX_MAP = {
+      controller: "Controller",
+      presenter:  "Presenter",
+      serializer: "Serializer"
+    }
+
+    def self.generate(type, args)
+      path = args[:path]
+      type = type.to_sym
+      raise "Unknown type: #{type}" unless ROOT_MAP.key?(type)
+
+      segments     = path.split("/")
+      file_name    = segments.pop
+      file_path    = "#{ROOT_MAP[type]}/#{segments.join("/")}/#{file_name}_#{type}.rb"
+      namespace    = segments.map { |seg| camelize(seg) }.join("::")
+      class_name   = "#{camelize(file_name)}#{SUFFIX_MAP[type]}"
+      full_class   = [namespace, class_name].reject(&:empty?).join("::")
+
+      FileUtils.mkdir_p(File.dirname(file_path))
+      File.write(file_path, template(full_class, type))
+
+      puts "✅ Created #{file_path}"
+    end
+
+    def self.camelize(str)
+      str.split(/[_-]/).map { |part| part.capitalize }.join
+    end
+
+    def self.template(full_class, type)
+      base_class = {
+        controller: "AppController",
+        presenter:  "AppPresenter",
+        serializer: "AppSerializer"
+      }[type]
+
+      namespace = full_class.split("::")[0..-2].join("::")
+      class_name = full_class.split("::").last
+
+      <<~RUBY
+        module #{namespace}
+          class #{class_name} < #{base_class}
+            def call
+              # TODO: implement
+            end
+          end
+        end
+      RUBY
+    end
+  end
+end

data/lib/rsodx/cli/commands/generators/action.rb

@@ -0,0 +1,13 @@
+module Rsodx::Cli::Commands::Generators
+  class Action < Dry::CLI::Command
+    desc "Generate full action (controller + serializer + presenter)"
+
+    argument :path, desc: "Path to endpoint (e.g. v1/users/index)"
+
+    def call(args)
+      %i[controller serializer presenter].each do |type|
+        Rsodx::Cli::Generator.generate(type, args)
+      end
+    end
+  end
+end

data/lib/rsodx/cli/commands/generators/controller.rb

@@ -0,0 +1,12 @@
+module Rsodx::Cli::Commands::Generators
+  class Controller < Dry::CLI::Command
+    desc "Generate a controller"
+
+    argument :path, desc: "Path to controller, e.g. v1/users/index"
+
+    def call(args)
+      Rsodx::Cli::Generator.generate(:controller, args)
+    end
+  end
+end
+

data/lib/rsodx/cli/commands/generators/migration.rb

@@ -0,0 +1,52 @@
+require "fileutils"
+require "time"
+
+module Rsodx
+  module Cli
+    module Commands
+      module Generators
+        class Migration < Dry::CLI::Command
+          desc "Generate a Sequel migration"
+
+          argument :name, required: true, desc: "Name of the migration"
+
+          def call(name:)
+            timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+            file_name = File.join("db/migrations", "#{timestamp}_#{snake_case(name)}.rb")
+
+            puts "📦 Creating migration: #{file_name}"
+            FileUtils.mkdir_p("db/migrations")
+            File.write(file_name, MIGRATION_TEMPLATE)
+
+            puts "✅ Done"
+          rescue => e
+            abort "❌ Failed to generate migration: #{e.message}"
+          end
+
+          private
+
+          MIGRATION_TEMPLATE = <<~MIGRATION_TEMPLATE.freeze
+          Sequel.migration do
+            change do
+              # create_table(:example) do
+              #   primary_key :id
+              #   String :name
+              #   DateTime :created_at
+              #   DateTime :updated_at
+              # end
+            end
+          end
+          MIGRATION_TEMPLATE
+
+          def snake_case(str)
+            str.gsub(/::/, '/')
+               .gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2')
+               .gsub(/([a-z\\d])([A-Z])/,'\\1_\\2')
+               .tr("-", "_")
+               .downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsodx/cli/commands/generators/presenter.rb

@@ -0,0 +1,11 @@
+module Rsodx::Cli::Commands::Generators
+  class Presenter < Dry::CLI::Command
+    desc "Generate presenter"
+
+    argument :path, desc: "Path to presenter (e.g. v1/users/index)"
+
+    def call(args)
+      Rsodx::Cli::Generator.generate(:presenter, args)
+    end
+  end
+end

data/lib/rsodx/cli/commands/generators/serializer.rb

@@ -0,0 +1,11 @@
+module Rsodx::Cli::Commands::Generators
+  class Serializer < Dry::CLI::Command
+    desc "Generate serializer"
+
+    argument :path, desc: "Path to serializer (e.g. v1/users/index)"
+
+    def call(args)
+      Rsodx::Cli::Generator.generate(:serializer, args)
+    end
+  end
+end