vert-core 1.0.0

data/lib/vert/authorization/policy_finder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Vert
+  module Authorization
+    class PolicyFinder
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def policy
+        find_policy || DynamicPolicy
+      end
+
+      def policy!
+        policy || raise(Pundit::NotDefinedError, "Unable to find policy for #{object}")
+      end
+
+      def scope
+        find_scope || DynamicPolicy::Scope
+      end
+
+      def scope!
+        scope || raise(Pundit::NotDefinedError, "Unable to find scope for #{object}")
+      end
+
+      private
+
+      def find_policy
+        specific_policy = "#{model_name}Policy"
+        return Object.const_get(specific_policy) if Object.const_defined?(specific_policy)
+
+        namespaced_policy = "#{model_namespace}::#{model_class_name}Policy"
+        return Object.const_get(namespaced_policy) if Object.const_defined?(namespaced_policy)
+
+        service_policy = "#{service_name}::DynamicPolicy"
+        return Object.const_get(service_policy) if Object.const_defined?(service_policy)
+
+        nil
+      rescue NameError
+        nil
+      end
+
+      def find_scope
+        policy_class = find_policy
+        return nil unless policy_class
+        policy_class.const_defined?(:Scope) ? policy_class::Scope : nil
+      end
+
+      def model_name
+        case object
+        when Class then object.name
+        when Symbol, String then object.to_s.camelize
+        else object.class.name
+        end
+      end
+
+      def model_class_name
+        model_name.demodulize
+      end
+
+      def model_namespace
+        model_name.deconstantize.presence || "App"
+      end
+
+      def service_name
+        model_namespace.underscore.split("/").first.camelize
+      end
+    end
+  end
+end

data/lib/vert/clients/document_service_client.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "base64"
+
+module Vert
+  module Clients
+    class DocumentServiceClient
+      attr_reader :base_url, :timeout
+
+      def initialize(base_url: nil, timeout: 30)
+        @base_url = base_url || Vert.config.document_service_url
+        @timeout = timeout
+      end
+
+      def upload(resource:, filename:, content:, content_type:, metadata: {})
+        uri = URI.parse("#{base_url}/api/v1/objects")
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        add_auth_headers(request)
+        request.body = {
+          object: {
+            resource: resource,
+            original_filename: filename,
+            content_type: content_type,
+            content_base64: Base64.strict_encode64(content.to_s),
+            metadata: metadata
+          }
+        }.to_json
+        execute_request(uri, request)
+      end
+
+      def download_url(object_id:, disposition: "inline", expires_in: 3600)
+        uri = URI.parse("#{base_url}/api/v1/objects/#{object_id}/download_url")
+        uri.query = URI.encode_www_form(disposition: disposition, expires_in: expires_in)
+        request = Net::HTTP::Get.new(uri)
+        add_auth_headers(request)
+        execute_request(uri, request)
+      end
+
+      def download(object_id:)
+        result = download_url(object_id: object_id)
+        return nil unless result[:success]
+        url = result[:data][:url]
+        response = Net::HTTP.get_response(URI.parse(url))
+        response.body if response.is_a?(Net::HTTPSuccess)
+      end
+
+      def object(object_id)
+        uri = URI.parse("#{base_url}/api/v1/objects/#{object_id}")
+        request = Net::HTTP::Get.new(uri)
+        add_auth_headers(request)
+        execute_request(uri, request)
+      end
+
+      def delete_object(object_id)
+        uri = URI.parse("#{base_url}/api/v1/objects/#{object_id}")
+        request = Net::HTTP::Delete.new(uri)
+        add_auth_headers(request)
+        execute_request(uri, request)
+      end
+
+      def list_objects(resource: nil, page: 1, per_page: 20)
+        uri = URI.parse("#{base_url}/api/v1/objects")
+        params = { page: page, per_page: per_page }
+        params[:resource] = resource if resource
+        uri.query = URI.encode_www_form(params)
+        request = Net::HTTP::Get.new(uri)
+        add_auth_headers(request)
+        execute_request(uri, request)
+      end
+
+      private
+
+      def execute_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+        response = http.request(request)
+        case response
+        when Net::HTTPSuccess
+          body = JSON.parse(response.body, symbolize_names: true)
+          { success: true, data: body[:data] || body }
+        else
+          body = (JSON.parse(response.body, symbolize_names: true) rescue {})
+          { success: false, error: body[:error] || response.message, status: response.code.to_i }
+        end
+      rescue StandardError => e
+        { success: false, error: e.message }
+      end
+
+      def add_auth_headers(request)
+        request["Accept"] = "application/json"
+        request["X-Tenant-ID"] = Vert::Current.tenant_id.to_s if Vert::Current.tenant_id
+        request["X-Company-ID"] = Vert::Current.company_id.to_s if Vert::Current.company_id
+        request["X-User-ID"] = Vert::Current.user_id.to_s if Vert::Current.user_id
+        request["X-Request-ID"] = Vert::Current.request_id.to_s if Vert::Current.request_id
+      end
+    end
+  end
+end

data/lib/vert/concerns/auditable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Vert
+  module Concerns
+    module Auditable
+      extend ActiveSupport::Concern
+
+      included do
+        before_create :set_created_by
+        before_update :set_updated_by
+      end
+
+      private
+
+      def set_created_by
+        self.created_by ||= Vert::Current.user_id if has_attribute?(:created_by)
+      end
+
+      def set_updated_by
+        self.updated_by = Vert::Current.user_id if has_attribute?(:updated_by)
+      end
+    end
+  end
+end

data/lib/vert/concerns/company_scoped.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Vert
+  module Concerns
+    module CompanyScoped
+      extend ActiveSupport::Concern
+
+      included do
+        validates :company_id, presence: true
+        validate :company_belongs_to_tenant, if: -> { tenant_id.present? && company_id.present? }
+        default_scope do
+          if Vert::Current.company_id.present?
+            where(company_id: Vert::Current.company_id)
+          else
+            all
+          end
+        end
+        before_validation :set_company_id, on: :create
+      end
+
+      class_methods do
+        def for_company(company_id)
+          unscope(where: :company_id).where(company_id: company_id)
+        end
+
+        def all_companies
+          unscope(where: :company_id)
+        end
+
+        def belongs_to_current_company?(id)
+          exists?(id: id)
+        end
+      end
+
+      private
+
+      def set_company_id
+        self.company_id ||= Vert::Current.company_id
+      end
+
+      def company_belongs_to_tenant
+        return unless defined?(Company)
+        return if Company.unscoped.exists?(id: company_id, tenant_id: tenant_id)
+        errors.add(:company_id, "does not belong to the current tenant")
+      end
+    end
+  end
+end

data/lib/vert/concerns/current_attributes.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Vert
+  module Concerns
+    # CurrentAttributes - Thread-safe request context
+    class Current < ActiveSupport::CurrentAttributes
+      attribute :tenant_id, :company_id, :user_id, :request_id, :rls_configured
+
+      def self.reset_all
+        reset
+      end
+
+      def self.set_context(tenant_id:, user_id: nil, company_id: nil, request_id: nil)
+        self.tenant_id = tenant_id
+        self.user_id = user_id
+        self.company_id = company_id
+        self.request_id = request_id || SecureRandom.uuid
+      end
+
+      def self.serialize
+        { tenant_id: tenant_id, user_id: user_id, company_id: company_id, request_id: request_id }
+      end
+
+      def self.deserialize(hash)
+        return unless hash.is_a?(Hash)
+        set_context(
+          tenant_id: hash[:tenant_id] || hash["tenant_id"],
+          user_id: hash[:user_id] || hash["user_id"],
+          company_id: hash[:company_id] || hash["company_id"],
+          request_id: hash[:request_id] || hash["request_id"]
+        )
+      end
+
+      def self.tenant_set?
+        tenant_id.present?
+      end
+
+      def self.company_set?
+        company_id.present?
+      end
+
+      def self.require_tenant!
+        raise Vert::TenantNotSetError, "Tenant context not set" unless tenant_set?
+      end
+
+      def self.require_company!
+        raise Vert::CompanyNotSetError, "Company context not set" unless company_set?
+      end
+    end
+  end
+
+  Current = Concerns::Current
+end

data/lib/vert/concerns/document_storeable.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Vert
+  module Concerns
+    module DocumentStoreable
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :document_attachments, default: {}
+      end
+
+      class_methods do
+        def has_document(name, resource:, content_type: nil)
+          document_attachments[name] = { resource: resource, content_type: content_type }
+
+          define_method(name) do
+            object_id = send("#{name}_object_id")
+            return nil unless object_id.present?
+            @document_cache ||= {}
+            @document_cache[name] ||= Vert::Concerns::DocumentStoreable::DocumentAttachment.new(
+              object_id: object_id,
+              resource: document_attachments[name][:resource],
+              owner: self
+            )
+          end
+
+          define_method("#{name}=") do |value|
+            return if value.nil?
+            result = attach_document(name, value)
+            if result[:success]
+              send("#{name}_object_id=", result[:data][:id])
+              @document_cache&.delete(name)
+            else
+              errors.add(name, "upload failed: #{result[:error]}")
+            end
+          end
+
+          define_method("attach_#{name}") do |content:, filename:, content_type: nil|
+            config = self.class.document_attachments[name]
+            ct = content_type || config[:content_type] || detect_content_type(filename)
+            result = document_service_client.upload(
+              resource: config[:resource],
+              filename: filename,
+              content: content,
+              content_type: ct,
+              metadata: document_metadata(name)
+            )
+            if result[:success]
+              send("#{name}_object_id=", result[:data][:id])
+              @document_cache&.delete(name)
+            else
+              errors.add(name, "upload failed: #{result[:error]}")
+            end
+            result
+          end
+
+          define_method("#{name}_attached?") { send("#{name}_object_id").present? }
+
+          define_method("purge_#{name}") do
+            object_id = send("#{name}_object_id")
+            return true unless object_id.present?
+            result = document_service_client.delete_object(object_id)
+            if result[:success]
+              send("#{name}_object_id=", nil)
+              @document_cache&.delete(name)
+              true
+            else
+              false
+            end
+          end
+        end
+      end
+
+      private
+
+      def document_service_client
+        @document_service_client ||= Vert::Clients::DocumentServiceClient.new
+      end
+
+      def attach_document(name, value)
+        config = self.class.document_attachments[name]
+        case value
+        when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+          document_service_client.upload(
+            resource: config[:resource],
+            filename: value.original_filename,
+            content: value.read,
+            content_type: value.content_type || config[:content_type],
+            metadata: document_metadata(name)
+          )
+        when Hash
+          document_service_client.upload(
+            resource: config[:resource],
+            filename: value[:filename],
+            content: value[:content],
+            content_type: value[:content_type] || config[:content_type],
+            metadata: document_metadata(name)
+          )
+        when String
+          document_service_client.upload(
+            resource: config[:resource],
+            filename: "#{name}_#{id || SecureRandom.uuid}.bin",
+            content: value,
+            content_type: config[:content_type] || "application/octet-stream",
+            metadata: document_metadata(name)
+          )
+        else
+          { success: false, error: "Invalid value type for document" }
+        end
+      end
+
+      def document_metadata(name)
+        metadata = { owner_type: self.class.name, owner_id: id, field_name: name.to_s }
+        metadata[:tenant_id] = tenant_id if respond_to?(:tenant_id)
+        metadata[:company_id] = company_id if respond_to?(:company_id)
+        metadata
+      end
+
+      def detect_content_type(filename)
+        ext = File.extname(filename).downcase
+        CONTENT_TYPES[ext] || "application/octet-stream"
+      end
+
+      CONTENT_TYPES = {
+        ".xml" => "application/xml", ".pdf" => "application/pdf",
+        ".png" => "image/png", ".jpg" => "image/jpeg", ".jpeg" => "image/jpeg", ".gif" => "image/gif",
+        ".csv" => "text/csv", ".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ".xls" => "application/vnd.ms-excel", ".doc" => "application/msword",
+        ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ".zip" => "application/zip", ".txt" => "text/plain", ".json" => "application/json"
+      }.freeze
+    end
+
+    class DocumentStoreable::DocumentAttachment
+      attr_reader :storage_object_id, :resource, :owner
+
+      def initialize(object_id:, resource:, owner:)
+        @storage_object_id = object_id
+        @resource = resource
+        @owner = owner
+      end
+
+      def url(disposition: "inline", expires_in: 3600)
+        result = client.download_url(object_id: storage_object_id, disposition: disposition, expires_in: expires_in)
+        result[:success] ? result[:data][:url] : nil
+      end
+
+      def download
+        client.download(object_id: storage_object_id)
+      end
+
+      def details
+        result = client.object(storage_object_id)
+        result[:success] ? result[:data] : nil
+      end
+
+      def filename
+        details&.dig(:original_filename)
+      end
+
+      def content_type
+        details&.dig(:mime_type)
+      end
+
+      def byte_size
+        details&.dig(:size)
+      end
+
+      def attached?
+        storage_object_id.present?
+      end
+
+      private
+
+      def client
+        @client ||= Vert::Clients::DocumentServiceClient.new
+      end
+    end
+  end
+end

data/lib/vert/concerns/multi_tenant.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Vert
+  module Concerns
+    module MultiTenant
+      extend ActiveSupport::Concern
+
+      included do
+        validates :tenant_id, presence: true, if: :require_tenant_id?
+        default_scope do
+          if Vert::Current.tenant_id.present?
+            where(tenant_id: Vert::Current.tenant_id)
+          else
+            all
+          end
+        end
+        before_validation :set_tenant_id, on: :create
+      end
+
+      class_methods do
+        def unscoped_for_tenant(tenant_id)
+          unscoped.where(tenant_id: tenant_id)
+        end
+
+        def all_tenants
+          unscoped
+        end
+
+        def belongs_to_current_tenant?(id)
+          exists?(id: id)
+        end
+      end
+
+      private
+
+      def require_tenant_id?
+        true
+      end
+
+      def set_tenant_id
+        self.tenant_id ||= Vert::Current.tenant_id
+      end
+    end
+  end
+end

data/lib/vert/concerns/soft_deletable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "discard"
+
+module Vert
+  module Concerns
+    module SoftDeletable
+      extend ActiveSupport::Concern
+
+      included do
+        include ::Discard::Model
+        default_scope -> { kept }
+      end
+
+      class_methods do
+        def deleted
+          discarded
+        end
+
+        def active
+          kept
+        end
+
+        def with_deleted
+          with_discarded
+        end
+
+        def only_deleted
+          discarded
+        end
+      end
+
+      def soft_delete
+        discard
+      end
+
+      def restore
+        undiscard
+      end
+
+      def deleted?
+        discarded?
+      end
+    end
+  end
+end

data/lib/vert/concerns/uuid_primary_key.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Vert
+  module Concerns
+    module UuidPrimaryKey
+      extend ActiveSupport::Concern
+
+      included do
+        before_create :set_uuid
+      end
+
+      private
+
+      def set_uuid
+        return unless has_attribute?(:id)
+        return if id.present?
+        self.id = generate_uuid_v7
+      end
+
+      def generate_uuid_v7
+        if SecureRandom.respond_to?(:uuid_v7)
+          SecureRandom.uuid_v7
+        else
+          generate_uuid_v7_fallback
+        end
+      end
+
+      def generate_uuid_v7_fallback
+        timestamp_ms = (Time.now.to_f * 1000).to_i
+        random_bytes = SecureRandom.random_bytes(10)
+        bytes = [
+          (timestamp_ms >> 40) & 0xFF, (timestamp_ms >> 32) & 0xFF, (timestamp_ms >> 24) & 0xFF,
+          (timestamp_ms >> 16) & 0xFF, (timestamp_ms >> 8) & 0xFF, timestamp_ms & 0xFF,
+          (0x70 | (random_bytes[0] & 0x0F)), random_bytes[1], (0x80 | (random_bytes[2] & 0x3F)),
+          random_bytes[3], random_bytes[4], random_bytes[5], random_bytes[6], random_bytes[7], random_bytes[8], random_bytes[9]
+        ].pack("C*")
+        hex = bytes.unpack1("H*")
+        "#{hex[0..7]}-#{hex[8..11]}-#{hex[12..15]}-#{hex[16..19]}-#{hex[20..31]}"
+      end
+    end
+  end
+end

data/lib/vert/configuration.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Vert
+  # Configuração central da gem. Todos os recursos são opcionais e ativados no initializer.
+  #
+  # @example config/initializers/vert.rb
+  #   Vert.configure do |config|
+  #     config.enable_rls = true
+  #     config.enable_outbox = true
+  #     config.enable_health = true
+  #     config.rabbitmq_url = ENV["RABBITMQ_URL"]
+  #   end
+  class Configuration
+    # --- Flags de funcionalidade (todos opcionais) ---
+    attr_accessor :enable_rls,
+                  :enable_outbox,
+                  :enable_health,
+                  :enable_authorization,
+                  :enable_multi_tenant,
+                  :enable_auditable,
+                  :enable_soft_deletable,
+                  :enable_uuid_primary_key,
+                  :enable_company_scoped,
+                  :enable_document_storeable
+
+    # --- RLS (Row Level Security) ---
+    attr_accessor :rls_user
+
+    # --- RabbitMQ / Outbox ---
+    attr_accessor :rabbitmq_url, :exchange_name
+
+    # --- Document service client ---
+    attr_accessor :document_service_url
+
+    # --- Health ---
+    attr_accessor :health_check_path, :auto_mount_health_routes,
+                  :health_check_database, :health_check_redis,
+                  :health_check_rabbitmq, :health_check_sidekiq
+
+    def initialize
+      # Funcionalidades desativadas por padrão; ative no initializer conforme necessário
+      @enable_rls = false
+      @enable_outbox = false
+      @enable_health = true
+      @enable_authorization = false
+      @enable_multi_tenant = false
+      @enable_auditable = false
+      @enable_soft_deletable = false
+      @enable_uuid_primary_key = false
+      @enable_company_scoped = false
+      @enable_document_storeable = false
+
+      @rls_user = ENV.fetch("RLS_USER", "app_user")
+      @rabbitmq_url = ENV.fetch("RABBITMQ_URL", "amqp://guest:guest@localhost:5672/")
+      @exchange_name = ENV.fetch("RABBITMQ_EXCHANGE", "vert.events")
+      @document_service_url = ENV.fetch("DOCUMENT_SERVICE_URL", "http://localhost:3020")
+      @health_check_path = "/health"
+      @auto_mount_health_routes = false
+      @health_check_database = true
+      @health_check_redis = false
+      @health_check_rabbitmq = false
+      @health_check_sidekiq = false
+    end
+  end
+end