rrx_api 0.1.0 → 8.0.3

data/app/models/concerns/arel_query.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module ArelQuery
+  extend ActiveSupport::Concern
+
+  module Cast
+    def self.included(mod)
+      mod.class_eval do
+        alias_method :create_cast, :cast if method_defined?(:cast)
+
+        def cast(type)
+          ::Arel::Nodes::NamedFunction.new "CAST", [self.as(type)]
+        end
+      end
+    end
+  end
+
+  class WithHelper
+    attr_reader :name
+
+    def initialize(name, relation)
+      raise ArgumentError, 'Name must be a Symbol or String' unless name.is_a?(Symbol) || name.is_a?(String)
+      raise ArgumentError, 'Relation must be an Arel node or select manager' unless relation.is_a?(Arel::Nodes::Node) || relation.is_a?(Arel::SelectManager)
+
+      @name     = name
+      @relation = relation
+    end
+
+    def [](column)
+      table[column]
+    end
+
+    def table
+      @table ||= Arel::Table.new(@name)
+    end
+
+    def to_cte
+      Arel::Nodes::Cte.new(@name, @relation)
+    end
+  end
+
+  class ArelHelper
+    attr_reader :model
+
+    delegate :star, :sql, to: Arel
+    delegate :project, :where, :from, :join, :outer_join, :group, :order, :alias, to: :@table
+    delegate :with, to: :from
+
+    def initialize(model)
+      @model = model
+      @table = model.arel_table if model.respond_to?(:arel_table)
+    end
+
+    def table(name = nil)
+      if name
+        Arel::Table.new(name)
+      elsif @table
+        @table
+      else
+        raise ArgumentError, 'No table available. Provide a table name.'
+      end
+    end
+
+    alias t table
+
+    def literal(value)
+      Arel::Nodes::SqlLiteral.new(value.to_s)
+    end
+
+    alias l   literal
+    alias lit literal
+
+    def string(value)
+      literal "'#{value}'"
+    end
+
+    alias s   string
+    alias str string
+
+    # @return [Arel::SelectManager]
+    def select(...)
+      Arel::SelectManager.new(...)
+    end
+
+    def as(what, alias_name)
+      raise ArgumentError, 'Alias name must be a Symbol or String' unless alias_name.is_a?(Symbol) || alias_name.is_a?(String)
+
+      Arel::Nodes::As.new(what, literal(alias_name))
+    end
+
+    def for_with(name, relation)
+      WithHelper.new(name, relation)
+    end
+
+    def results(query)
+      connection.select_all(query)
+    end
+
+    def rows(query)
+      results(query).to_a
+    end
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    FUNCTION_METHOD_PATTERN = /\A[a-z]+(_[a-z]+)*\z/
+
+    def method_missing(method_name, *args, &block)
+      node_class = "Arel::Nodes::#{method_name.to_s.camelize}".safe_constantize
+
+      if node_class
+        self.class.define_method method_name do |*method_args|
+          node_class.new(*method_args)
+        end
+      elsif @table&.respond_to?(method_name)
+        return @table.send(method_name, *args)
+      elsif method_name.to_s =~ FUNCTION_METHOD_PATTERN
+        self.class.define_method method_name do |*method_args|
+          Arel::Nodes::NamedFunction.new(method_name.to_s, method_args)
+        end
+      else
+        return super
+      end
+
+      send(method_name, *args)
+    end
+
+    def column(name)
+      @table[name]
+    end
+
+    alias col column
+    alias c   column
+
+    def [](it)
+      case it
+      when Symbol
+        @table[it]
+      when String
+        string(it)
+      else
+        literal(it)
+      end
+    end
+  end
+
+  class_methods do
+    def aq(*args)
+      @arel_helper ||= ArelHelper.new(self)
+      args.empty? ? @arel_helper : @arel_helper.sql(*args)
+    end
+  end
+
+  included do
+    def aq(...)
+      self.class.aq(...)
+    end
+  end
+end
+
+ActiveSupport.on_load :active_record do
+  class ::Arel::SelectManager
+    def table
+      @ast.cores[0].source.left
+    end
+
+    def join_to(other, from: :id, to: :id, on: nil, type: :inner)
+      on ||= table[from].eq(other[to])
+      join_node_class = case type
+                        when :inner        then Arel::Nodes::InnerJoin
+                        when :left, :outer then Arel::Nodes::OuterJoin
+                        when :right        then Arel::Nodes::RightOuterJoin
+                        when :full         then Arel::Nodes::FullOuterJoin
+                        else raise ArgumentError, "Unknown join type: #{type.inspect}"
+                        end
+
+      other = other.table if other.respond_to?(:table)
+      join(other, join_node_class).on(on)
+    end
+  end
+
+  ::Arel::Nodes::Node.include(ArelQuery::Cast)
+  ::Arel::Attributes::Attribute.include(ArelQuery::Cast)
+end

data/app/models/rrx_api/record.rb

@@ -4,9 +4,21 @@ module RrxApi
   class Record < ActiveRecord::Base
     self.abstract_class = true
 
+    include ArelQuery
+
+    before_create :set_new_id
+
     # @return [RrxLogging::Logger]
     def logger
       @logger ||= RrxLogging.current || Rails.logger
     end
+
+    protected
+
+    def set_new_id
+      self.id ||= Random.uuid if has_attribute?(:id)
+    end
+
   end
+
 end

data/config/routes.rb

@@ -0,0 +1,13 @@
+RrxApi::Engine.routes.draw do
+  if Rails.root.join('swagger').exist?
+    require 'rswag/api/engine'
+    require 'rswag/ui/engine'
+
+    mount Rswag::Ui::Engine => '/api-docs'
+    mount Rswag::Api::Engine => '/api-docs'
+  end
+
+  healthcheck_path = Rails.application.config.healthcheck_route
+  healthcheck_path = "/#{healthcheck_path}" unless healthcheck_path.start_with?('/')
+  get healthcheck_path => 'rrx_api/health#show', as: :rrx_health_check
+end

data/lib/generators/rrx_api/base.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RrxApi
+  module Generators
+    class Base < ::Rails::Generators::Base
+      hide!
+
+      def self.init!(description = nil)
+        # noinspection RubyMismatchedArgumentType
+        source_root Pathname(__dir__).join('templates')
+        desc description if description
+      end
+
+      protected
+
+      # class Version
+      #   def initialize(str)
+      #     @version = str.to_s
+      #     @segments = @version.split('.').map(&:to_i)
+      #   end
+      #
+      #   def to_s
+      #     @version
+      #   end
+      #
+      #   def major
+      #     @segments[0]
+      #   end
+      #
+      #   def minor
+      #     @segments[1]
+      #   end
+      #
+      #   def build
+      #     @segments[2] || 0
+      #   end
+      #
+      #   def major_minor
+      #     "#{major}.#{minor}"
+      #   end
+      #
+      #   def <=>(other)
+      #     return nil unless other.is_a?(Version)
+      #
+      #     result = major <=> other.major
+      #     result = minor <=> other.minor if result.zero?
+      #     result = build <=> other.build if result.zero?
+      #     result
+      #   end
+      # end
+
+      def destination_path
+        @destination_path = Pathname(destination_root)
+      end
+
+      def app_name
+        @app_name ||= destination_path.basename.to_s
+      end
+
+      # @return [String] Current Ruby version in format "MAJOR.MINOR"
+      def ruby_version
+        @ruby_version ||= bundle_max_ruby_version || current_ruby_version
+      end
+
+      # @return [Bundler::Definition]
+      def bundle
+        @bundle ||= Bundler::Definition.build(
+          destination_path.join('Gemfile'),
+          destination_path.join('Gemfile.lock'),
+          nil
+        )
+      end
+
+      def current_ruby_version
+        RUBY_VERSION.split('.')[0..1].join('.')
+      end
+
+      def bundle_max_ruby_version
+        return nil unless bundle.ruby_version
+
+        version   = Gem::Requirement.new(*bundle.ruby_version.versions)
+        max_minor = version
+                      .requirements
+                      .map { |_, v| v.segments[0..1] } # [major, minor]
+
+        if max_minor.any?
+          max_minor.min_by { |major, minor| [major, minor] }.join('.')
+        else
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/generators/rrx_api/docker_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RrxApi
+  module Generators
+    class DockerGenerator < Base
+      init! 'Generates configuration files for building a docker image.'
+
+      class_option :image_name, type: :string, desc: 'Name of the Docker image. Defaults to application name.'
+
+      def docker
+        template 'docker/Dockerfile.tt', 'Dockerfile'
+      end
+
+      alias image_name app_name
+    end
+  end
+end

data/lib/generators/rrx_api/github_generator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require_relative 'base'
+
+module RrxApi
+  module Generators
+    class GithubGenerator < Base
+      init! 'Generates GitHub Actions workflows for building and deploying the application using Docker.'
+
+      class_option :deploy,
+                   type:    :boolean,
+                   default: false,
+                   desc:    'Include deployment workflow'
+
+      class_option :terraform_repo,
+                   type:    :string,
+                   default: 'terraform',
+                   desc:    'Terraform repository name (if using deployment workflow)'
+
+      class_option :terraform_module,
+                   type: :string,
+                   desc: 'Terraform module name (if using deployment workflow). Default is the application name.'
+
+      class_option :database,
+                   type:    :string,
+                   default: 'auto',
+                   enum:    %w[auto postgresql mysql mariadb sqlite none],
+                   desc:    'Database type'
+
+      def github
+        directory 'github/build', '.github'
+        directory 'github/deploy', '.github' if deploy?
+      end
+
+      private
+
+      def deploy?
+        options[:deploy]
+      end
+
+      def database
+        @database ||= options[:database] == 'auto' ? detect_database : options[:database]
+      end
+
+      def terraform_repo
+        options[:terraform_repo]
+      end
+
+      def terraform_module
+        options[:terraform_module] || app_name
+      end
+
+      def docker_packages
+        ''
+      end
+
+      def detect_database
+        config_path = destination_path.join('config/database.yml')
+        if config_path.exist?
+          # @type {Hash}
+          config  = YAML.safe_load(config_path.read, symbolize_names: true, aliases: true)
+          adapter = config.dig(:test, :adapter).to_s.downcase
+          case adapter
+          when /postgresql/, /psql/
+            'postgresql'
+          when /mysql/
+            if yes?('Detected MySQL adapter in database.yml. Are you using MariaDB? (Yn)')
+              'mariadb'
+            else
+              'mysql'
+            end
+          when /sqlite/
+            'sqlite'
+          else
+            say_error 'Unsupported database adapter detected in config/database.yml. Please specify the database type explicitly using --database option.'
+            exit 1
+          end
+        else
+          'none'
+        end
+      end
+    end
+  end
+end

data/lib/generators/rrx_api/install_generator.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+# frozen_string_literal: true
+require_relative 'base'
+
+module RrxApi
+  module Generators
+    class InstallGenerator < Base
+      init! 'Installs the RRX API gem and its dependencies.'
+
+      class_option :skip_rrx_dev, type: :boolean, default: false, hide: true
+
+      # Updates the application configuration file with specific dependencies and settings.
+      # The method performs the following operations:
+      # - Reads the application configuration file located at 'config/application.rb'.
+      # - Removes existing comments and unnecessary `require` statements from the file.
+      # - Includes necessary `require` directives for the application's gem dependencies.
+      # - Injects or updates the Bundler require statement to include the necessary gems.
+      # - Cleans up unwanted whitespace in the file content.
+      # - Rewrites the configuration file with the updated content.
+      # - Appends additional configuration settings for time zone, schema format, and session management.
+      #
+      # @return [void] Since the primary purpose is file modification, it does not return a value directly.
+      def update_application
+        # @type [Pathname]
+        app_file = Pathname(destination_root).join('config', 'application.rb')
+        app_code = app_file.read
+
+        # Assume full replace if we've never modified before.
+        # Otherwise, create_file will prompt to replace it.
+        remove_file app_file unless app_code =~ /rrx_api/
+
+        app_code.gsub!(/^\s*#.*\r?\n/, '')
+        app_code.gsub!(/^(?:#\s+)?require ["'].*\r?\n/, '')
+
+        requires = application_gems.map do |gem|
+          "require '#{gem}'"
+        end.join("\n")
+
+        app_code.sub!(/^(Bundler.require.*)$/) do |str|
+          <<~REQ
+            #{requires}
+
+            #{str}
+          REQ
+        end
+
+        # Remove existing application config lines
+        APPLICATION_CONFIG.each do |line|
+          app_code.gsub!(/^\s*#{line}\W*.*\n/, '')
+        end
+
+        # Remove unnecessary whitespace
+        app_code.lstrip!
+        app_code.gsub!(/^\s*\r?\n(\s*\r?\n)+/, "\n")
+
+        # puts app_code
+        create_file app_file, app_code
+      end
+
+      def update_base_classes
+        gsub_file 'app/models/application_record.rb',
+                  /ApplicationRecord.*/,
+                  'ApplicationRecord < RrxApi::Record'
+
+        gsub_file 'app/controllers/application_controller.rb',
+                  /ApplicationController.*/,
+                  'ApplicationController < RrxApi::Controller'
+      end
+
+      def routes
+        inject_into_file 'config/routes.rb',
+                         after: "Rails.application.routes.draw do\n" do
+          <<~RUBY
+            mount RrxApi::Engine => '/'
+          RUBY
+        end
+      end
+
+      def rrx_dev
+        generate 'rrx_dev:install' unless options[:skip_rrx_dev]
+      end
+
+      def asdf_versions
+        create_file '.tool-versions', <<~VERSIONS
+          ruby #{ruby_version}
+        VERSIONS
+      end
+
+      private
+
+      # Configs to remove from the application.rb file
+      APPLICATION_CONFIG = <<~CONFIG.split("\n").map(&:strip).freeze
+        config.time_zone
+        config.active_support.to_time_preserves_timezone
+        config.active_record.schema_format
+        config.session_store
+        config.middleware.use ActionDispatch::Cookies
+        config.middleware.use ActionDispatch::Session::CookieStore
+      CONFIG
+
+      # @return [Array<String>] The list of application gem names that are dependencies
+      def application_gems
+        gems = %w[rrx_api]
+        gems.concat(%w[rrx_jobs active_job].select { |name| gem?(name) })
+      end
+
+      # @param [String] name
+      # @return [Boolean] True if gem is a dependency
+      def gem?(name)
+        bundle_gems.include?(name)
+      end
+
+      # @return [Set<String>]
+      def bundle_gems
+        @bundle_gems ||= bundle.dependencies.map(&:name).to_set
+      end
+
+    end
+  end
+end

data/lib/generators/rrx_api/templates/docker/Dockerfile.tt

@@ -0,0 +1 @@
+FROM ddrew555/rrx_docker:<%= ruby_version %>

data/lib/generators/rrx_api/templates/github/build/workflows/build.yml.tt

@@ -0,0 +1,71 @@
+name: Build
+
+on:
+  workflow_dispatch:
+<% if deploy? %>
+    inputs:
+      dev_deploy:
+        type: boolean
+        default: true
+        description: 'Deploy build to development environment'
+<% end %>
+
+  push:
+    branches: [main]
+
+env:
+  image_name: '<%= app_name %>'
+  major_version: 1
+  minor_version: 0
+  development: ${{ github.ref_name != 'main' }}
+
+permissions: write-all
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: dan-drew/asdf-actions/tool-versions@v1
+
+      - name: Test
+        uses: rails-rrx/actions/test@main
+        with:
+          ruby_version: <%= ruby_version %>
+          database: <%= database %>
+
+      - uses: dan-drew/actions/next-version@main
+        with:
+          suffix: ${{ env.development && '-dev' || '' }}
+
+      - name: Build
+        uses: rails-rrx/actions/docker-build@main
+        with:
+          repository: ${{ vars.DOCKER_REPOSITORY }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+          image_name: $${{ env.image_name }}
+          image_version: ${{ env.next_version }}
+          database: <%= database %>
+          latest: true
+          packages: '<%= docker_packages %>'
+
+      - uses: dan-drew/actions/push-version@main
+        if: ${{ ! env.development }}
+<% if deploy? %>
+      - name: Deploy Development
+        uses: actions/github-script@v7
+        condition: ${{ inputs.dev_deploy }}
+        with:
+          script: |
+            github.rest.actions.createWorkflowDispatch({
+              owner:        context.repo.owner,
+              repo:         context.repo.repo,
+              workflow_id:  'deploy.yml',
+              ref:          context.ref,
+              inputs:       { version: '${{ env.next_version }}' }
+            });
+<% end %>

data/lib/generators/rrx_api/templates/github/deploy/workflows/deploy.yml.tt

@@ -0,0 +1,62 @@
+name: Deploy
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        required: true
+        type: string
+        description: 'Version to deploy'
+      environment:
+        default: development
+        type: string
+        description: 'Environment to deploy'
+
+env:
+  image_name: '<%= app_name %>'
+  image_tag: "${{ inputs.version }}"
+  terraform_repo: '<%= terraform_repo %>'
+  terraform_module: '<%= terraform_module %>'
+  repository: ${{ vars.DOCKER_REPOSITORY }}
+  username: ${{ secrets.DOCKER_USERNAME }}
+  password: ${{ secrets.DOCKER_PASSWORD }}
+
+permissions: write-all
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Tag Docker Image
+        run: |
+          readonly image_ref="${repository}/${image_name}"
+          readonly source_image="${image_ref}:${image_tag}"
+          readonly dest_image="${image_ref}:${{ inputs.environment }}"
+
+          echo ::group::Login
+          cat <<-PASSWORD | docker login "$repository" -u "$username" --password-stdin
+          ${password}
+          PASSWORD
+          echo ::endgroup::
+
+          echo ::group::Tag
+          docker pull -q "${source_image}"
+          docker tag "${source_image}" "${dest_image}"
+          docker push -q "${dest_image}"
+          echo ::endgroup::
+
+      - name: Trigger Terraform
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.TERRAFORM_GITHUB_TOKEN }}
+          script: |
+            github.rest.repos.createDispatchEvent({
+              owner:        context.repo.owner,
+              repo:         'terraform',
+              event_type:   'apply',
+
+              client_payload: {
+                path:         '${{ env.terraform_module }}',
+                environment:  '${{ inputs.environment }}'
+              }
+            });