rails_studio 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 527dfed966038785c8daa627f6dd25d9dd1c161eb72cae0e6a1f292573e089e1
+  data.tar.gz: fddc652d53d6ecd07542ef13ff6fa531d3cb7fb3afe75672eb05def6bff9ef2c
+SHA512:
+  metadata.gz: 3815a4daac5fa289c97c873fbcde262c91c2953e8a1e30d6226e98d1f26144ab96cb4d3e8683ae0baa8e5fbbf92aecd05aa2766bd877c521d6f47ccd52ceba6b
+  data.tar.gz: 9824be2b206f1032848d8bbb3306b866e7efbafb811edfb3e57e460aceefa903bfc7ef7bdb2d6473ac350e3ce61866e79a4e280192e0154fba963b771f3d9268

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-21
+
+### Added
+
+- First public release of Rails Studio as a mountable Rails engine
+- Spreadsheet-like table browser with inline editing and staged commits
+- Foreign key drawer and relation navigation
+- SQL query runner and interactive Rails console
+- Command palette, keyboard shortcuts, and light/dark themes
+
+[Unreleased]: https://github.com/yuler/rails_studio/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/yuler/rails_studio/releases/tag/v0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright yuler
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="assets/logo-light.svg">
+    <img alt="Rails Studio" src="assets/logo.svg" width="160">
+  </picture>
+</p>
+
+<p align="center">
+  <strong>A modern, fast, and beautiful Web Database Studio for Rails development.</strong><br>
+  Inspired by <a href="https://github.com/prisma/studio">Prisma Studio</a> and <a href="https://orm.drizzle.team/drizzle-studio/overview">Drizzle Studio</a>.
+</p>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/rails_studio"><img src="https://img.shields.io/gem/v/rails_studio?color=e11d48&label=gem" alt="Gem Version"></a>
+  <a href="https://github.com/yuler/rails_studio/blob/main/MIT-LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
+  <a href="https://rubyonrails.org/"><img src="https://img.shields.io/badge/rails-%3E%3D%207.0-red.svg" alt="Rails 7+"></a>
+  <a href="#-inspiration"><img src="https://img.shields.io/badge/inspired%20by-Prisma%20%26%20Drizzle%20Studio-6366f1.svg" alt="Inspiration"></a>
+</p>
+
+<p align="center">
+  <video src="assets/intro.mp4" poster="assets/intro-poster.jpg" width="800" autoplay loop muted playsinline controls>
+    <a href="assets/intro.mp4"><img src="assets/intro-poster.jpg" alt="Rails Studio intro: browse tables, filter, inline edit, SQL, and Rails console" width="800"></a>
+  </video>
+</p>
+
+---
+
+Rails Studio is packaged as a **mountable Rails Engine** with zero dependencies required by the host application (pre-compiled SPA bundled with the gem — **no Node.js or NPM needed in your Rails app!**).
+
+## 💡 Inspiration
+
+Rails Studio was heavily inspired by the remarkable developer experience of two pioneering tools in the modern TypeScript & full-stack ecosystem:
+
+- **[Prisma Studio](https://github.com/prisma/studio)** — The visual, spreadsheet-like database browser for the Prisma ecosystem.
+- **[Drizzle Studio](https://orm.drizzle.team/drizzle-studio/overview)** — The lightning-fast, modern database studio for Drizzle ORM.
+
+We wanted to bring that exact same fluid, intuitive, spreadsheet-like database exploration and editing experience to the **Ruby on Rails** and **Active Record** ecosystem — with zero configuration, packaged cleanly as a mountable Rails engine.
+
+---
+
+## ✨ Features
+
+- **🚀 One-Line Integration**: Mount directly inside your Rails `routes.rb` under development with zero configuration.
+- **📦 Zero-Dependency Delivery**: Pre-compiled SPA bundled with the gem—no Node.js, Webpack, or asset pipeline setup required.
+- **📊 Spreadsheet-like UX**: Browse, filter, sort, and inline-edit records in an interactive table with column badges and sticky headers.
+- **🔗 Association Navigation**: Click foreign key badges to inspect and traverse referenced records in a side drawer.
+- **💾 Git-like Staging**: Review edited cells locally before committing multiple updates atomically in a single database transaction.
+- **⚡ SQL Query Runner**: Execute arbitrary SQL queries with query templates, execution timers, and CSV export.
+- **💻 Embedded Rails Console**: Run Ruby and Active Record code in an integrated browser terminal with auto-completion and SQL traces.
+- **⌨️ Keyboard-First & Command Palette**: Navigate tables and trigger actions rapidly via `Cmd+K` and built-in keyboard shortcuts.
+- **🎨 Dark & Light Modes**: Seamless theme switching with automatic system detection and persistent user preferences.
+- **🗄️ Database Agnostic**: Works out of the box with PostgreSQL, MySQL, SQLite, Trilogy, and any adapter supported by Active Record.
+- **🧩 Modern Rails Ready**: Fully compatible with Rails 7.1+, 8.0+, composite primary keys, and multi-database architectures.
+
+---
+
+## 🔍 How It Works
+
+Rails Studio operates as a lightweight, self-contained Rails Engine:
+
+1. **Mountable Engine**: Plugs directly into your Rails application pipeline via `config/routes.rb` without affecting your application logic.
+2. **Schema & Association Reflection**: Dynamically introspects your Active Record models, column types, and relationships using your existing database connections.
+3. **Pre-bundled SPA**: Delivers a modern React frontend directly from the gem's static assets, requiring no JavaScript toolchain in your host app.
+4. **Safe Transactions & In-Process Console**: Communicates with internal engine API endpoints to stage edits, commit atomic transactions, and evaluate console commands safely within your Rails runtime.
+
+---
+
+## 🚀 Quickstart
+
+Add to your `Gemfile` and mount the engine in `config/routes.rb`:
+
+```ruby
+# Gemfile
+group :development do
+  gem "rails_studio"
+end
+
+# config/routes.rb
+Rails.application.routes.draw do
+  mount RailsStudio::Engine => "/rails_studio" if Rails.env.development?
+end
+```
+
+Start your server (`bin/rails server`) and visit [http://localhost:3000/rails_studio](http://localhost:3000/rails_studio).
+
+---
+
+## ⚙️ Configuration (Optional)
+
+You can customize Rails Studio by adding an initializer: `config/initializers/rails_studio.rb`:
+
+```ruby
+RailsStudio.configure do |config|
+  # Allow access in production (Default: false, strongly recommended to keep false)
+  config.allow_in_production = false
+
+  # Read-only mode: prevents updates, creates, and deletes (Default: false)
+  config.read_only = false
+
+  # Default pagination records per page (Default: 50)
+  config.default_per_page = 50
+
+  # Maximum records allowed per page (Default: 200)
+  config.max_per_page = 200
+
+  # Tables excluded from sidebar and inspection
+  config.excluded_tables += %w[my_secret_table]
+end
+```
+
+---
+
+## 🛠️ Development
+
+We use [`mise`](https://mise.jdx.dev/) to manage development tasks:
+
+```bash
+mise run setup  # Install dependencies, build assets & prepare test DB
+mise run dev    # Start Rails server with frontend build watch
+mise run build  # Compile frontend assets into public/assets/
+mise run test   # Run automated test suite
+```
+
+> **Manual setup**: `bundle install`, `pnpm --dir frontend install && pnpm --dir frontend build`, `cd test/dummy && bin/rails db:migrate db:seed`, then `bin/rails server`.
+
+---
+
+## 📦 Releasing
+
+Maintainers: bump `lib/rails_studio/version.rb`, update `CHANGELOG.md`, run `mise run build`, then `bundle exec rake release`. See [RELEASING.md](RELEASING.md).
+
+---
+
+## 📄 License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"

data/app/assets/stylesheets/rails_studio/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/rails_studio/api/console_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsStudio
+  module Api
+    class ConsoleController < ApplicationController
+      def execute
+        result = Console.execute(params[:command])
+        render json: result
+      end
+
+      def completions
+        result = Console.completions
+        render json: result
+      end
+    end
+  end
+end

data/app/controllers/rails_studio/api/overview_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RailsStudio
+  module Api
+    class OverviewController < ApplicationController
+      def show
+        render json: Database.current.overview
+      end
+    end
+  end
+end

data/app/controllers/rails_studio/api/query_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RailsStudio
+  module Api
+    class QueryController < ApplicationController
+      def execute
+        result = Query.execute(params[:sql])
+        render json: result
+      rescue ActiveRecord::StatementInvalid => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      rescue RailsStudio::ReadOnlyError => e
+        render json: { error: e.message }, status: :forbidden
+      rescue StandardError => e
+        render json: { error: e.message }, status: :internal_server_error
+      end
+    end
+  end
+end

data/app/controllers/rails_studio/api/records_controller.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RailsStudio
+  module Api
+    class RecordsController < ApplicationController
+      def index
+        table = Table.find(params[:table_name])
+        filters = parse_filters(params[:filters])
+
+        result = table.records(
+          page: params[:page],
+          per_page: params[:per_page],
+          sort_by: params[:sort_by],
+          sort_order: params[:sort_order],
+          filters: filters
+        )
+
+        render json: result
+      end
+
+      def show
+        table = Table.find(params[:table_name])
+        record = table.find_record(params[:id])
+        if record
+          render json: { record: record }
+        else
+          render json: { error: "Record not found" }, status: :not_found
+        end
+      end
+
+      def create
+        table = Table.find(params[:table_name])
+        record = table.create_record(record_params)
+        render json: { success: true, record: record }, status: :created
+      rescue ActiveRecord::RecordInvalid => e
+        render json: { success: false, error: e.message, errors: e.record.errors.full_messages }, status: :unprocessable_entity
+      rescue ActiveRecord::StatementInvalid => e
+        render json: { success: false, error: e.message }, status: :unprocessable_entity
+      end
+
+      def update
+        table = Table.find(params[:table_name])
+        record = table.update_record(params[:id], record_params)
+        render json: { success: true, record: record }
+      rescue ActiveRecord::RecordInvalid => e
+        render json: { success: false, error: e.message, errors: e.record.errors.full_messages }, status: :unprocessable_entity
+      rescue ActiveRecord::StatementInvalid => e
+        render json: { success: false, error: e.message }, status: :unprocessable_entity
+      end
+
+      def destroy
+        table = Table.find(params[:table_name])
+        table.destroy_record(params[:id])
+        render json: { success: true }
+      end
+
+      def batch
+        table = Table.find(params[:table_name])
+        results = table.batch_process(
+          updates: params[:updates] || [],
+          creates: params[:creates] || [],
+          deletes: params[:deletes] || []
+        )
+
+        render json: { success: true, results: results }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }, status: :unprocessable_entity
+      end
+
+      private
+
+      def record_params
+        if params[:record].respond_to?(:permit!)
+          params.require(:record).permit!.to_h
+        elsif params[:record].is_a?(Hash)
+          params[:record]
+        else
+          {}
+        end
+      end
+
+      def parse_filters(raw_filters)
+        return [] if raw_filters.blank?
+
+        if raw_filters.is_a?(String)
+          parsed = JSON.parse(raw_filters) rescue []
+          parsed.is_a?(Array) ? parsed : []
+        elsif raw_filters.is_a?(Array)
+          raw_filters.map { |f| f.respond_to?(:to_unsafe_h) ? f.to_unsafe_h : f }
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/app/controllers/rails_studio/api/tables_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RailsStudio
+  module Api
+    class TablesController < ApplicationController
+      def schema
+        table = Table.find(params[:table_name])
+        render json: table.schema
+      end
+    end
+  end
+end

data/app/controllers/rails_studio/application_controller.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsStudio
+  class ApplicationController < ActionController::Base
+    skip_forgery_protection
+    before_action :ensure_access_allowed
+
+    rescue_from StandardError, with: :handle_standard_error
+    rescue_from ActionDispatch::Http::Parameters::ParseError, with: :handle_parse_error
+    rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
+    rescue_from RailsStudio::ReadOnlyError, with: :handle_read_only
+
+    private
+
+    def ensure_access_allowed
+      return if RailsStudio.configuration.allow_in_production?
+      return if Rails.env.development? || Rails.env.test?
+
+      render plain: "Rails Studio is only accessible in development or test environment.", status: :forbidden
+    end
+
+    def handle_not_found(exception)
+      render json: { error: exception.message }, status: :not_found
+    end
+
+    def handle_parse_error(exception)
+      render json: { error: "Invalid JSON format: #{exception.message}" }, status: :bad_request
+    end
+
+    def handle_read_only(exception)
+      render json: { error: exception.message }, status: :forbidden
+    end
+
+    def handle_standard_error(exception)
+      logger.error("[RailsStudio] #{exception.class}: #{exception.message}\n#{exception.backtrace&.first(5)&.join("\n")}")
+      render json: { error: exception.message }, status: :internal_server_error
+    end
+  end
+end

data/app/controllers/rails_studio/dashboard_controller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RailsStudio
+  class DashboardController < ApplicationController
+    LOGO_FILES = %w[logo.svg logo-light.svg logo-dark.svg].freeze
+
+    def index
+      script_name = request.script_name.presence || ""
+      # Normalizes prefix (removes trailing slash)
+      @base_path = script_name.sub(%r{/\z}, "")
+
+      respond_to do |format|
+        format.html { render "rails_studio/dashboard/index", layout: false }
+        format.all  { render "rails_studio/dashboard/index", layout: false, content_type: "text/html" }
+      end
+    end
+
+    def asset
+      relative_path = params[:path].to_s
+      relative_path = "#{relative_path}.#{params[:format]}" if params[:format].present? && !relative_path.end_with?(".#{params[:format]}")
+      public_dir = File.expand_path(File.join(Engine.root, "public", "assets"))
+      file_path = File.expand_path(File.join(public_dir, relative_path))
+
+      unless File.file?(file_path)
+        logo_dir = File.expand_path(File.join(Engine.root, "assets"))
+        logo_path = File.expand_path(File.join(logo_dir, File.basename(relative_path)))
+        if LOGO_FILES.include?(File.basename(logo_path)) && logo_path.start_with?("#{logo_dir}/") && File.file?(logo_path)
+          file_path = logo_path
+        end
+      end
+
+      served_from_public = file_path == public_dir || file_path.start_with?("#{public_dir}/")
+      served_from_logos = LOGO_FILES.include?(File.basename(file_path)) &&
+        file_path.start_with?("#{File.expand_path(File.join(Engine.root, "assets"))}/")
+
+      if (served_from_public || served_from_logos) && File.file?(file_path)
+        ext = File.extname(file_path).delete_prefix(".")
+        content_type = case ext
+        when "js", "mjs" then "application/javascript"
+        when "css" then "text/css"
+        when "svg" then "image/svg+xml"
+        when "json" then "application/json"
+        when "woff2" then "font/woff2"
+        when "woff" then "font/woff"
+        when "ttf" then "font/ttf"
+        when "png" then "image/png"
+        when "jpg", "jpeg" then "image/jpeg"
+        when "ico" then "image/x-icon"
+        else "application/octet-stream"
+        end
+
+        response.headers["Cache-Control"] = "public, max-age=31536000, immutable" if Rails.env.production?
+        send_file file_path, type: content_type, disposition: "inline"
+      else
+        head :not_found
+      end
+    end
+  end
+end

data/app/helpers/rails_studio/application_helper.rb

@@ -0,0 +1,4 @@
+module RailsStudio
+  module ApplicationHelper
+  end
+end

data/app/jobs/rails_studio/application_job.rb

@@ -0,0 +1,4 @@
+module RailsStudio
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/rails_studio/application_mailer.rb

@@ -0,0 +1,6 @@
+module RailsStudio
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/rails_studio/application_record.rb

@@ -0,0 +1,5 @@
+module RailsStudio
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/rails_studio/console.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "pp"
+
+module RailsStudio
+  class Console
+    EVAL_MUTEX = Mutex.new
+
+    DANGEROUS_PATTERNS = [
+      /\b(create!|create|destroy_all|destroy|delete_all|delete|update_all|update!|update|drop_table|execute|truncate)\b/,
+      /\b(save!|save|update_attribute|update_column|update_columns|toggle!)\b/
+    ].freeze
+
+    class << self
+      def execute(command)
+        clean_code = command.to_s.strip
+        if clean_code.blank?
+          return { result: nil, result_type: "NilClass", stdout: "", queries: [], duration_ms: 0 }
+        end
+
+        if RailsStudio.configuration.read_only?
+          validate_read_only_code!(clean_code)
+        end
+
+        queries = []
+        current_thread = Thread.current
+        subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+          next unless Thread.current == current_thread
+
+          event = ActiveSupport::Notifications::Event.new(*args)
+          unless event.payload[:name] == "SCHEMA"
+            queries << {
+              sql: event.payload[:sql],
+              duration_ms: event.duration.round(2)
+            }
+          end
+        end
+
+        stdout_buf = StringIO.new
+        duration_ms = 0
+
+        begin
+          result = nil
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          EVAL_MUTEX.synchronize do
+            old_stdout = $stdout
+            $stdout = stdout_buf
+            begin
+              result = if RailsStudio.configuration.read_only? && ActiveRecord::Base.respond_to?(:while_preventing_writes)
+                         ActiveRecord::Base.while_preventing_writes do
+                           TOPLEVEL_BINDING.eval(clean_code)
+                         end
+              else
+                         TOPLEVEL_BINDING.eval(clean_code)
+              end
+            ensure
+              $stdout = old_stdout
+            end
+          end
+
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+
+          formatted_result = if result.nil?
+                               "nil"
+          elsif result.is_a?(String)
+                               result.inspect
+          else
+                               PP.pp(result, String.new, 100).strip
+          end
+
+          {
+            result: formatted_result,
+            result_type: result.class.name,
+            stdout: stdout_buf.string,
+            queries: queries,
+            duration_ms: duration_ms
+          }
+        rescue Exception => e
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2) rescue 0
+          {
+            error: {
+              class: e.class.name,
+              message: e.message,
+              backtrace: clean_backtrace(e.backtrace)
+            },
+            stdout: stdout_buf.string,
+            queries: queries,
+            duration_ms: duration_ms
+          }
+        ensure
+          ActiveSupport::Notifications.unsubscribe(subscriber)
+        end
+      end
+
+      def completions
+        Rails.application.eager_load! rescue nil
+
+        all_models = ActiveRecord::Base.descendants.reject(&:abstract_class?).select { |m| m.name.present? }
+        app_models = all_models.reject { |m| m.name.to_s.start_with?("Action", "ActiveStorage") }
+        framework_models = all_models.select { |m| m.name.to_s.start_with?("Action", "ActiveStorage") }
+        sorted_models = app_models + framework_models
+
+        models = sorted_models.map do |model|
+          {
+            name: model.name,
+            table_name: model.table_name,
+            columns: (model.column_names rescue []),
+            associations: (model.reflect_on_all_associations.map(&:name).map(&:to_s) rescue [])
+          }
+        end
+
+        common_methods = %w[
+          all count first last find find_by where pluck order limit
+          group having select distinct joins includes create create!
+          new build destroy_all delete_all update_all to_sql explain
+          columns column_names table_name primary_key
+        ]
+
+        rails_globals = %w[
+          Rails.env Rails.application Rails.version Rails.root
+          ActiveRecord::Base
+        ]
+
+        {
+          models: models,
+          common_methods: common_methods,
+          globals: rails_globals
+        }
+      end
+
+      private
+
+      def validate_read_only_code!(code)
+        if DANGEROUS_PATTERNS.any? { |pattern| code =~ pattern }
+          raise RailsStudio::ReadOnlyError, "Modifying operations are disabled in read-only mode."
+        end
+      end
+
+      def clean_backtrace(backtrace)
+        return [] unless backtrace.is_a?(Array)
+
+        backtrace.first(6).map do |line|
+          line.sub(Rails.root.to_s, ".")
+        end
+      end
+    end
+  end
+end