railsmaker-core 0.0.1

data/lib/railsmaker/generators/auth_generator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class AuthGenerator < BaseGenerator
+      source_root File.expand_path('templates/auth', __dir__)
+
+      def add_gems
+        gem_group :default do
+          gem 'clearance', '~> 2.9.3'
+          gem 'omniauth', '~> 2.1.2'
+          gem 'omniauth-google-oauth2', '~> 1.2.1'
+          gem 'omniauth-rails_csrf_protection', '~> 1.0.2'
+        end
+
+        run 'bundle install'
+      end
+
+      def setup_clearance
+        generate 'clearance:install'
+        rake 'db:migrate'
+        generate 'clearance:views'
+      end
+
+      def configure_clearance
+        gsub_file 'config/initializers/clearance.rb',
+                  'config.mailer_sender = "reply@example.com"',
+                  'config.mailer_sender = Rails.application.credentials.dig(:app, :mailer_sender)'
+
+        inject_into_file 'config/initializers/clearance.rb', after: 'Clearance.configure do |config|' do
+          "\n  config.redirect_url = \"/demo\""
+        end
+      end
+
+      def setup_omniauth
+        create_file 'config/initializers/omniauth.rb' do
+          <<~RUBY
+            # frozen_string_literal: true
+
+            Rails.application.config.middleware.use OmniAuth::Builder do
+              provider :google_oauth2,
+                Rails.application.credentials.dig(:google_oauth, :client_id),
+                Rails.application.credentials.dig(:google_oauth, :client_secret),
+                {
+                  scope: "email",
+                  prompt: "select_account"
+                }
+            end
+
+            OmniAuth.config.allowed_request_methods = %i[get]
+          RUBY
+        end
+
+        generate 'migration', 'AddOmniauthToUsers provider:string uid:string'
+        inject_into_file Dir['db/migrate/*add_omniauth_to_users.rb'].first,
+                         after: "add_column :users, :uid, :string\n" do
+          <<-RUBY
+    add_index :users, [:provider, :uid], unique: true
+          RUBY
+        end
+
+        inject_into_file 'app/models/user.rb', after: "include Clearance::User\n" do
+          <<-RUBY
+
+  def self.from_omniauth(auth)
+    where(provider: auth.provider, uid: auth.uid).first_or_create do |user|
+      user.email = auth.info.email
+      user.password = SecureRandom.hex(10)
+    end
+  end
+          RUBY
+        end
+
+        rake 'db:migrate'
+      end
+
+      def add_omniauth_controller
+        template 'app/controllers/omniauth_callbacks_controller.rb',
+                 'app/controllers/omniauth_callbacks_controller.rb'
+      end
+
+      def update_routes
+        route <<~RUBY
+          # OmniAuth callback routes
+          get "auth/:provider/callback", to: "omniauth_callbacks#google_oauth2", constraints: { provider: "google_oauth2" }
+          get 'auth/failure', to: 'omniauth_callbacks#failure'
+        RUBY
+      end
+
+      def git_commit
+        git add: '.', commit: %(-m 'Add authentication with Clearance and OmniAuth')
+
+        say 'Successfully added authentication with Clearance and OmniAuth', :green
+      end
+    end
+  end
+end

data/lib/railsmaker/generators/base_generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class BaseGenerator < Rails::Generators::Base
+      class BaseGeneratorError < StandardError; end
+
+      include Rails::Generators::Actions
+      include GsubValidation
+
+      def self.default_command_options
+        { abort_on_failure: true }
+      end
+
+      protected
+
+      def run(*args)
+        options = args.extract_options!
+        options = self.class.default_command_options.merge(options)
+        super(*args, options.merge(force: true)) # do not ask for confirmation on overrides
+      end
+
+      private
+
+      def check_required_env_vars(required_vars)
+        missing_vars = required_vars.reject { |var| ENV[var].present? }
+
+        return if missing_vars.empty?
+
+        say "\nError: Missing required environment variables:", :red
+        missing_vars.each { |var| say "  - #{var}", :red }
+        say "\nPlease set these environment variables before continuing:", :red
+        missing_vars.each { |var| say "  export #{var}=your-value", :yellow }
+
+        raise BaseGeneratorError, 'Missing required environment variables'
+      end
+    end
+  end
+end

data/lib/railsmaker/generators/concerns/gsub_validation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    module GsubValidation
+      def validate_gsub_strings(validations)
+        validations.each do |validation|
+          file_path = File.join(destination_root, validation.fetch(:file))
+
+          unless File.exist?(file_path)
+            raise "Required file not found: #{validation.fetch(:file)}. Maybe a dependency changed?"
+          end
+
+          content = File.read(file_path)
+          validation.fetch(:patterns).each do |pattern|
+            unless content.include?(pattern)
+              raise "Expected to find '#{pattern}' in #{validation.fetch(:file)} but didn't. Maybe a dependency changed?"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/railsmaker/generators/litestream_generator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class LitestreamGenerator < BaseGenerator
+      source_root File.expand_path('templates/litestream', __dir__)
+
+      class_option :bucketname, type: :string, required: true, desc: 'Litestream bucketname'
+      class_option :name, type: :string, required: true, desc: 'Application name for volume and bucket naming'
+      class_option :ip, type: :string, required: true, desc: 'Server IP address'
+
+      def check_required_env_vars
+        super(%w[
+          LITESTREAM_ACCESS_KEY_ID
+          LITESTREAM_SECRET_ACCESS_KEY
+          LITESTREAM_ENDPOINT
+          LITESTREAM_REGION
+        ])
+      end
+
+      def create_litestream_config
+        template 'litestream.yml.erb', 'config/litestream.yml'
+      end
+
+      def add_kamal_secrets
+        inject_into_file '.kamal/secrets', after: "RAILS_MASTER_KEY=$(cat config/master.key)\n" do
+          <<~YAML
+
+            # Litestream credentials for S3-compatible storage
+            LITESTREAM_ACCESS_KEY_ID=$LITESTREAM_ACCESS_KEY_ID
+            LITESTREAM_SECRET_ACCESS_KEY=$LITESTREAM_SECRET_ACCESS_KEY
+            LITESTREAM_ENDPOINT=$LITESTREAM_ENDPOINT
+            LITESTREAM_REGION=$LITESTREAM_REGION
+            LITESTREAM_BUCKET_NAME=#{options[:bucketname]}
+          YAML
+        end
+      end
+
+      def add_to_deployment
+        validations = [
+          {
+            file: 'config/deploy.yml',
+            patterns: ["bin/rails dbconsole\"\n", "arch: amd64\n"]
+          }
+        ]
+
+        validate_gsub_strings(validations)
+
+        inject_into_file 'config/deploy.yml', after: "arch: amd64\n" do
+          <<~YAML
+
+            accessories:
+              litestream:
+                image: litestream/litestream:0.3
+                host: #{options[:ip]}
+                volumes:
+                  - "#{options[:name].underscore}_storage:/rails/storage"
+                files:
+                  - config/litestream.yml:/etc/litestream.yml
+                cmd: replicate -config /etc/litestream.yml
+                env:
+                  secret:
+                    - LITESTREAM_ACCESS_KEY_ID
+                    - LITESTREAM_SECRET_ACCESS_KEY
+                    - LITESTREAM_ENDPOINT
+                    - LITESTREAM_REGION
+                    - LITESTREAM_BUCKET_NAME
+          YAML
+        end
+
+        inject_into_file 'config/deploy.yml', after: "bin/rails dbconsole\"\n" do
+          <<-YAML
+  restore-db-app: accessory exec litestream "restore -if-replica-exists -config /etc/litestream.yml /rails/storage/production.sqlite3"
+  restore-db-cache: accessory exec litestream "restore -if-replica-exists -config /etc/litestream.yml /rails/storage/production_cache.sqlite3"
+  restore-db-queue: accessory exec litestream "restore -if-replica-exists -config /etc/litestream.yml /rails/storage/production_queue.sqlite3"
+  restore-db-cable: accessory exec litestream "restore -if-replica-exists -config /etc/litestream.yml /rails/storage/production_cable.sqlite3"
+  restore-db-ownership: server exec "sudo chown -R 1000:1000 /var/lib/docker/volumes/#{options[:name].underscore}_storage/_data/"
+          YAML
+        end
+      end
+
+      def git_commit
+        git add: '.', commit: %(-m 'Add Litestream configuration')
+
+        say 'Successfully added Litestream configuration', :green
+      end
+    end
+  end
+end

data/lib/railsmaker/generators/mailjet_generator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class MailjetGenerator < BaseGenerator
+      source_root File.expand_path('templates/mailjet', __dir__)
+
+      class_option :name, type: :string, required: true, desc: 'Name of the service for email sender'
+      class_option :domain, type: :string, required: true, desc: 'Host domain for the application'
+
+      def initialize(*args)
+        super
+        @name = options[:name]
+        @domain = options[:domain]
+      end
+
+      def add_gem
+        gem_group :default do
+          gem 'mailjet', '~> 1.8'
+        end
+
+        run 'bundle install'
+      end
+
+      def create_initializer
+        create_file 'config/initializers/mailjet.rb' do
+          <<~RUBY
+            # frozen_string_literal: true
+
+            Mailjet.configure do |config|
+              config.api_key = Rails.application.credentials.dig(:mailjet, :api_key)
+              config.secret_key = Rails.application.credentials.dig(:mailjet, :secret_key)
+              config.default_from = Rails.application.credentials.dig(:app, :mailer_sender)
+              config.api_version = "v3.1"
+            end
+          RUBY
+        end
+      end
+
+      def configure_mailer
+        environment(nil, env: 'production') do
+          <<~RUBY
+            # Mailjet API configuration
+            config.action_mailer.delivery_method = :mailjet_api
+          RUBY
+        end
+
+        gsub_file 'app/mailers/application_mailer.rb',
+                  /default from: .+$/,
+                  'default from: Rails.application.credentials.dig(:app, :mailer_sender)'
+
+        gsub_file 'config/environments/production.rb',
+                  /config\.action_mailer\.default_url_options = \{ host: .+\}/,
+                  'config.action_mailer.default_url_options = { host: Rails.application.credentials.dig(:app, :host) }'
+      end
+
+      def git_commit
+        git add: '.', commit: %(-m 'Add Mailjet configuration')
+
+        say 'Successfully added Mailjet configuration', :green
+      end
+
+      private
+
+      attr_reader :name, :domain
+    end
+  end
+end

data/lib/railsmaker/generators/opentelemetry_generator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class OpentelemetryGenerator < BaseGenerator
+      source_root File.expand_path('templates/opentelemetry', __dir__)
+
+      class_option :name, type: :string, required: true, desc: 'Name of the application'
+
+      def add_kamal_config
+        validations = [
+          {
+            file: 'config/deploy.yml',
+            patterns: [
+              "web:\n",
+              "SOLID_QUEUE_IN_PUMA: true\n"
+            ]
+          }
+        ]
+
+        validate_gsub_strings(validations)
+
+        inject_into_file 'config/deploy.yml', after: "web:\n" do
+          <<-YAML
+    options:
+      "add-host": host.docker.internal:host-gateway
+          YAML
+        end
+
+        inject_into_file 'config/deploy.yml', after: "SOLID_QUEUE_IN_PUMA: true\n" do
+          <<-YAML
+    # OpenTelemetry env vars
+    OTEL_EXPORTER: otlp
+    OTEL_SERVICE_NAME: #{options[:name]}
+    OTEL_EXPORTER_OTLP_ENDPOINT: http://host.docker.internal:4318
+          YAML
+        end
+      end
+
+      def add_gems
+        gem_group :default do
+          gem 'opentelemetry-sdk', '~> 1.6.0'
+          gem 'opentelemetry-exporter-otlp', '~> 0.29.1'
+          gem 'opentelemetry-instrumentation-all', '~> 0.72.0'
+
+          gem 'lograge', '~> 0.14.0'
+          gem 'logstash-event', '~> 1.2.02'
+        end
+
+        run 'bundle install'
+      end
+
+      def configure_opentelemetry
+        environment_file = 'config/environment.rb'
+
+        prepend_to_file environment_file, "require 'opentelemetry/sdk'\n"
+        inject_into_file environment_file, before: 'Rails.application.initialize!' do
+          <<~RUBY
+
+            OpenTelemetry::SDK.configure do |c|
+              c.use_all unless Rails.env.development? || Rails.env.test?
+            end
+
+          RUBY
+        end
+      end
+
+      def setup_lograge
+        template 'lograge.rb.erb', 'config/initializers/lograge.rb'
+      end
+
+      def git_commit
+        git add: '.', commit: %(-m 'Add OpenTelemetry')
+
+        say 'Successfully added OpenTelemetry configuration', :green
+      end
+    end
+  end
+end

data/lib/railsmaker/generators/plausible_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class PlausibleGenerator < ServerCommandGenerator
+      source_root File.expand_path('templates/shell_scripts', __dir__)
+
+      class_option :analytics_host, type: :string, required: true,
+                                    desc: 'Domain where Plausible Analytics will be hosted'
+
+      def initialize(*args)
+        super
+        @analytics_host = options[:analytics_host]
+      end
+
+      private
+
+      def script_name
+        'plausible'
+      end
+
+      def check_path
+        '~/plausible-ce'
+      end
+
+      def title
+        "Installing Plausible Analytics on remote server #{options[:ssh_user]}@#{options[:ssh_host]}"
+      end
+
+      attr_reader :analytics_host
+    end
+  end
+end

data/lib/railsmaker/generators/plausible_instrumentation_generator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class PlausibleInstrumentationGenerator < BaseGenerator
+      class_option :domain, type: :string, required: true, desc: 'Domain of your application'
+      class_option :analytics, type: :string, required: true, desc: 'Domain where Plausible is hosted'
+
+      def add_plausible_script
+        content = <<~HTML.indent(4)
+          <%# Plausible Analytics %>
+          <script defer data-domain="#{options[:domain]}" src="https://#{options[:analytics]}/js/script.file-downloads.outbound-links.pageview-props.revenue.tagged-events.js"></script>
+          <script>window.plausible = window.plausible || function() { (window.plausible.q = window.plausible.q || []).push(arguments) }</script>
+        HTML
+
+        gsub_file 'app/views/layouts/application.html.erb',
+                  %r{<%# Plausible Analytics %>.*?</script>\s*<script>.*?</script>}m,
+                  content.strip.to_s
+      end
+
+      def git_commit
+        git add: '.', commit: %(-m 'Add Plausible Analytics')
+
+        say 'Successfully added Plausible Analytics', :green
+      end
+    end
+  end
+end

data/lib/railsmaker/generators/sentry_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class SentryGenerator < BaseGenerator
+      def add_gems
+        gem_group :default do
+          gem 'sentry-ruby', '~> 5.22.3'
+          gem 'sentry-rails', '~> 5.22.3'
+        end
+
+        run 'bundle install'
+      end
+
+      def generate_sentry_initializer
+        generate 'sentry'
+
+        validations = [
+          {
+            file: 'config/initializers/sentry.rb',
+            patterns: [
+              'Sentry.init'
+            ]
+          }
+        ]
+
+        validate_gsub_strings(validations)
+      end
+
+      def configure_sentry
+        gsub_file 'config/initializers/sentry.rb', /Sentry\.init.*end\n/m do
+          <<~RUBY
+            Sentry.init do |config|
+              config.dsn = Rails.application.credentials.dig(:sentry_dsn)
+              config.breadcrumbs_logger = [ :active_support_logger, :http_logger ]
+            end
+          RUBY
+        end
+      end
+
+      def git_commit
+        git add: '.', commit: %(-m 'Add Sentry')
+      end
+    end
+  end
+end

data/lib/railsmaker/generators/server_command_generator.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'fileutils'
+require 'base64'
+require 'securerandom'
+
+module RailsMaker
+  module Generators
+    class ServerCommandGenerator < BaseGenerator
+      source_root File.expand_path('templates/shell_scripts', __dir__)
+
+      class_option :ssh_host, type: :string, required: true, desc: 'SSH host'
+      class_option :ssh_user, type: :string, required: true, desc: 'SSH user'
+      class_option :key_path, type: :string, desc: 'Path to SSH private key (optional)'
+      class_option :force, type: :boolean, default: false,
+                           desc: 'Force installation even if already installed'
+
+      def execute_script
+        return unless ssh_available?
+
+        say "⚠️  WARNING: This command will SSH into #{options[:ssh_user]}@#{options[:ssh_host]} and install software.",
+            :yellow
+        return unless yes?('Do you want to proceed? (y/N)')
+
+        # Generate random suffix for tmp files
+        random_suffix = SecureRandom.hex(8)
+
+        remote_files_content = remote_files.map do |file|
+          tmp_filename = "#{file[:filename]}.#{random_suffix}"
+          template file[:template], "/tmp/#{tmp_filename}"
+          content = File.read("/tmp/#{tmp_filename}")
+          FileUtils.rm("/tmp/#{tmp_filename}")
+          [tmp_filename, Base64.strict_encode64(content)]
+        end.to_h
+
+        file_commands = remote_files_content.map do |filename, content|
+          [
+            "echo '#{content}' | base64 -d > /tmp/#{filename}",
+            filename.end_with?("install_script.sh.#{random_suffix}") ? "chmod +x /tmp/#{filename}" : nil
+          ]
+        end.flatten.compact
+
+        execute_remote_commands(
+          [
+            *file_commands,
+            "/tmp/install_script.sh.#{random_suffix}",
+            *remote_files_content.keys.map { |filename| "rm /tmp/#{filename}" }
+          ],
+          title: title,
+          check_path: check_path,
+          force: options[:force]
+        )
+      end
+
+      protected
+
+      def script_name
+        raise NotImplementedError, 'Subclasses must implement #script_name'
+      end
+
+      def check_path
+        nil
+      end
+
+      def title
+        "Executing #{script_name} script"
+      end
+
+      def config_files
+        []
+      end
+
+      def remote_files
+        [
+          *config_files,
+          {
+            template: "#{script_name}.sh.erb",
+            filename: 'install_script.sh'
+          }
+        ]
+      end
+
+      def install_commands
+        [
+          '/tmp/install_script.sh',
+          *remote_files.map { |file| "rm /tmp/#{file[:filename]}" }
+        ]
+      end
+
+      private
+
+      def ssh_available?
+        return true if system('which ssh', out: File::NULL)
+
+        say_status 'error', 'SSH client not found. Please install SSH first.', :red
+        false
+      end
+
+      def ssh_destination
+        "#{options[:ssh_user]}@#{options[:ssh_host]}"
+      end
+
+      def ssh_options
+        opts = [
+          'StrictHostKeyChecking=accept-new',
+          'ConnectTimeout=10'
+        ]
+        opts.map { |opt| "-o #{opt}" }.join(' ')
+      end
+
+      def installation_exists?(check_path)
+        return false unless check_path
+
+        "[ -d #{check_path} ]"
+      end
+
+      def execute_remote_commands(commands, options = {})
+        if options[:key_path] && !File.exist?(File.expand_path(options[:key_path]))
+          say_status 'error', "SSH key not found: #{options[:key_path]}", :red
+          raise BaseGeneratorError, 'SSH key not found'
+        end
+
+        title = options[:title] || 'Executing remote commands'
+        say_status 'start', title, :blue
+
+        script_content = []
+
+        if options[:check_path] && !options[:force]
+          script_content << <<~SHELL
+            if #{installation_exists?(options[:check_path])}; then
+              echo "Installation already exists at #{options[:check_path]}"
+              echo "Use --force to reinstall"
+              exit 0
+            fi
+          SHELL
+        end
+
+        script_content += commands.map do |cmd|
+          <<~SHELL
+            echo "→ Executing: #{cmd}"
+            if ! #{cmd}; then
+              echo "✗ Command failed: #{cmd}"
+              raise BaseGeneratorError, "Command failed: #{cmd}"
+            fi
+          SHELL
+        end
+
+        script_content << 'exit 0'
+
+        ssh_cmd = ['ssh']
+        ssh_cmd << "-i #{options[:key_path]}" if options[:key_path]
+        ssh_cmd << ssh_options
+        ssh_cmd << ssh_destination
+        ssh_cmd << "'#{script_content.join("\n")}'"
+
+        success = system(ssh_cmd.join(' '))
+
+        if success
+          say_status 'success', 'All commands completed successfully', :green
+        else
+          say_status 'error', "Command failed with exit status #{$CHILD_STATUS.exitstatus}", :red
+          case $CHILD_STATUS.exitstatus
+          when 255
+            say '  → Could not connect to the server. Please check:', :red
+            say '    • SSH host and user are correct'
+            say '    • Your authentication credentials are valid'
+            say '    • Server is reachable and SSH port (22) is open'
+          when 126, 127
+            say '  → Command not found or not executable', :red
+            say '    • Ensure all required software is installed on the remote server'
+          end
+          exit $CHILD_STATUS.exitstatus
+        end
+      end
+    end
+  end
+end