rider-kick 0.0.12 → 0.0.13

data/lib/generators/rider_kick/structure_generator_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'generators/rider_kick/structure_generator'
+
+RSpec.describe 'rider_kick:structure generator' do
+  let(:klass) { RiderKick::Structure }
+
+  it 'mengangkat Thor::Error jika app/domains belum ada' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        expect(Dir.exist?('app/domains')).to be false
+        instance = klass.new(['Models::User'])           # ← instansiasi dengan argumen
+        expect { instance.generate_use_case }            # ← panggil task langsung
+          .to raise_error(Thor::Error, /clean_arch.*--setup/i)
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/structure_generator_success_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'active_support/inflector'
+require 'generators/rider_kick/structure_generator'
+require 'ostruct'
+
+RSpec.describe 'rider_kick:structure generator (success)' do
+  let(:klass) { RiderKick::Structure }
+
+  it 'membuat db/structures/<resource>_structure.yaml ketika environment valid' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        # 1) siapkan struktur minimal Clean Arch
+        FileUtils.mkdir_p('app/domains/core/use_cases')
+        FileUtils.mkdir_p('app/models/models')
+
+        # 2) stub namespace & model + metadata kolom
+
+        # 3) jalankan generator
+        instance = klass.new(['Models::User', 'actor:owner'])  # ← pakai token
+        instance.generate_use_case
+
+        # 4) verifikasi file output
+        expect(File).to exist('db/structures/users_structure.yaml')
+        yaml = File.read('db/structures/users_structure.yaml')
+        expect(yaml).to include('model: Models::User')
+        expect(yaml).to include('resource_name: users')
+        expect(yaml).to include('actor: owner')
+        expect(yaml).to include('- name')          # field dari kolom
+        expect(yaml).to include('- price')
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/templates/db/structures/example.yaml.tt

@@ -2,99 +2,131 @@ model: <%= @model_class %>
 resource_name: <%= @scope_path %>
 resource_owner_id: <%= @resource_owner_id %>
 actor: <%= @actor %>
+
 fields:
-<% @model_class.columns.each do |field| -%>
-  - <%= field.name.to_s %>
+<% @fields.each do |f| -%>
+- <%= f %>
 <% end -%>
-<% @uploaders.each do |field| -%>
-  - <%= field %>
+<% @uploaders.each do |f| -%>
+- <%= f %>
 <% end -%>
+
 uploaders:
-<% @uploaders.each do |field| -%>
-  - <%= field %>
+<% @uploaders.each do |f| -%>
+- <%= f %>
 <% end -%>
+
 search_able:
-<% contract_fields.each do |field| -%>
-<% if ['title', 'name'].include?(field) -%>
-  - <%= field %>
+<% @search_able.each do |f| -%>
+- <%= f %>
+<% end -%>
+
+# ---- Enriched metadata (opsional, untuk tooling/insight) ----
+schema:
+columns:
+<% columns_meta.each do |c| -%>
+- name: <%= c[:name] %>
+type: <%= c[:type] %>
+sql_type: <%= c[:sql_type] %>
+null: <%= c[:null] %>
+<% if c[:default].present? -%>
+default: <%= c[:default].inspect %>
+<% end -%>
+<% if c[:precision] || c[:scale] -%>
+precision: <%= c[:precision] || 'null' %>
+scale: <%= c[:scale] || 'null' %>
+<% end -%>
+<% if c[:limit] -%>
+limit: <%= c[:limit] %>
+<% end -%>
+<% end -%>
+foreign_keys:
+<% (fkeys_meta.presence || []).each do |fk| -%>
+- column: <%= fk[:column] %>
+to_table: <%= fk[:to_table] %>
+<% end -%>
+indexes:
+<% (indexes_meta.presence || []).each do |ix| -%>
+- columns: [<%= ix[:columns].join(', ') %>]
+unique: <%= ix[:unique] %>
+<% end -%>
+enums:
+<% if enums_meta.present? -%>
+<% enums_meta.each do |name, map| -%>
+<%= name %>: <%= map.keys %>
 <% end -%>
+<% else -%>
+{}
 <% end -%>
+
 controllers:
-  list_fields:
-<% @fields.each do |field| -%>
-    - <%= field %>
-<% end -%>
-  show_fields:
-<% @model_class.columns.each do |field| -%>
-    - <%= field.name.to_s %>
-<% end -%>
-<% @uploaders.each do |field| -%>
-    - <%= field %>
-<% end -%>
-  form_fields:
-<% (@fields).each do |field| -%>
-    - name: <%= field %>
-      type: string
-<% end -%>
-<% (@uploaders).each do |field| -%>
-<% if is_singular?(field) -%>
-    - name: <%= field %>
-      type: file
-<% else -%>
-    - name: <%= field %>
-      type: files
+list_fields:
+<% @fields.each do |f| -%>
+- <%= f %>
 <% end -%>
+show_fields:
+<% (@columns.map { _1[:name] } + @uploaders).uniq.each do |f| -%>
+- <%= f %>
 <% end -%>
-domains:
-  action_list:
-    use_case:
-      contract:
-  action_fetch_by_id:
-    use_case:
-      contract:
-        - required(:id).filled(:string)
-  action_create:
-    use_case:
-      contract:
-<% (@fields + @uploaders).each do |field| -%>
-  <% column_type = get_column_type(field) -%>
-  <% dry_type = @type_mapping[column_type.to_s] || ':string' -%>
-<% if @uploaders.include?(field) -%>
-<% if is_singular?(field) -%>
-    - optional(:<%= field %>).maybe(<%= dry_type %>)
-<% else -%>
-    - optional(:<%= field %>).maybe(:array)
+form_fields:
+<% @fields.each do |f| -%>
+- name: <%= f %>
+type: <%= get_column_type(f) %>
 <% end -%>
-<% else -%>
-    - required(:<%= field %>).filled(<%= dry_type %>)
-<% end -%>
-<% end -%>
-  action_update:
-    use_case:
-      contract:
-        - required(:id).filled(:string)
-<% (@fields + @uploaders).each do |field| -%>
-<% column_type = get_column_type(field) -%>
-<% dry_type = @type_mapping[column_type.to_s] || ':string' -%>
-<% if @uploaders.include?(field) -%>
-<% if is_singular?(field) -%>
-        - optional(:<%= field %>).maybe(<%= dry_type %>)
-<% else -%>
-        - optional(:<%= field %>).maybe(:array)
+<% @uploaders.each do |f| -%>
+- name: <%= f %>
+type: <%= is_singular?(f) ? 'file' : 'files' %>
 <% end -%>
-<% else -%>
-        - optional(:<%= field %>).maybe(<%= dry_type %>)
-<% end -%>
-<% end -%>
-  action_destroy:
-    use_case:
-      contract:
-        - required(:id).filled(:string)
+
+domains:
+action_list:
+use_case:
+contract:
+<% @search_able.each do |f| -%>
+# optional search fields: <%= f %>
+<% end -%>
+action_fetch_by_id:
+use_case:
+contract:
+- required(:id).filled(:string)
+<% if @resource_owner_id.present? -%>
+- required(:<%= @resource_owner_id %>).filled(:string)
+<% end -%>
+
+action_create:
+use_case:
+contract:
+<% if @resource_owner_id.present? -%>
+- required(:<%= @resource_owner_id %>).filled(:string)
+<% end -%>
+<% contract_lines_for_create.each do |line| -%>
+<%= line %>
+<% end -%>
+
+action_update:
+use_case:
+contract:
+- required(:id).filled(:string)
+<% if @resource_owner_id.present? -%>
+- required(:<%= @resource_owner_id %>).filled(:string)
+<% end -%>
+<% contract_lines_for_update.each do |line| -%>
+<%= line %>
+<% end -%>
+
+action_destroy:
+use_case:
+contract:
+- required(:id).filled(:string)
+<% if @resource_owner_id.present? -%>
+- required(:<%= @resource_owner_id %>).filled(:string)
+<% end -%>
+
 entity:
-  skipped_fields:
-    - id
-    - created_at
-    - updated_at
-<% if @model_class.columns.map(&:name).include?(:type) -%>
-    - type
-<% end -%>
+skipped_fields:
+- id
+- created_at
+- updated_at
+<% if @columns.map { _1[:name] }.include?('type') -%>
+- type
+<% end -%>

data/lib/generators/rider_kick/templates/domains/core/repositories/abstract_repository.rb.tt

@@ -7,18 +7,6 @@ class Core::Repositories::AbstractRepository
     extend(Core::Utils::RequestMethods)
   end
 
-  def parse_response(response)
-    begin
-      res = JSON.parse(response.body)
-    rescue => e
-      return Failure e
-    end
-    unless ['200', '201', '202'].include?(response.code.to_s)
-      return Failure Hashie::Mash.new(res)
-    end
-    Success Hashie::Mash.new(res)
-  end
-
   def error_messages_for(record)
     record.errors.to_a.join(', ')
   end

data/lib/generators/rider_kick/templates/domains/core/repositories/list.rb.tt

@@ -12,8 +12,8 @@ class Core::Repositories::<%= @scope_class %>::<%= @repository_class%> < Core::R
 <% else -%>
     resources = <%= @model_class %>
 <% end -%>
-    if @search.present?
-      resources = resources.where('<%= @search_able.map { |field| "LOWER(#{field}) LIKE :search" }.join(' OR ')%>', search: "%#{search}%")
+    if @search.present? && @search_able.any?
+      resources = resources.where("<%= @search_able.map { |f| "LOWER(#{f}) LIKE :search" }.join(' OR ') %>", search: "%#{@search.to_s.downcase}%")
     end
     return Success Hashie::Mash.new(response: [], meta: {}) unless resources.present?
     pagy, results = pagy(resources.order(created_at: :desc), limit: @per_page, page: @page)

data/lib/generators/rider_kick/templates/domains/core/utils/abstract_utils.rb.tt

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Core::Utils::AbstractUtils
+  include Dry::Monads[:result, :do]
+
+  def http
+    extend(Core::Utils::RequestMethods)
+  end
+
+  def error_messages_for(record)
+    record.errors.to_a.join(', ')
+  end
+
+  def build_errors(resource)
+    errors = []
+    resource.errors.each do |error|
+      errors << Core::Builders::Error.new(error.as_json).build
+    end
+    errors
+  end
+
+  def prepare!(params, sanitize: true)
+    if sanitize
+      Hashie::Mash.new(params.reject { |_, v| v.nil? || (v.is_a?(String) && v.blank?) })
+    else
+      Hashie::Mash.new(params)
+    end
+  end
+end

data/lib/generators/rider_kick/templates/domains/core/utils/request_methods.rb.tt

@@ -76,6 +76,7 @@ module Core::Utils::RequestMethods
     if is_ssl
       http.use_ssl = true
     end
-    http.request(request)
+    response = http.request(request)
+    parse_response(response)
   end
 end

data/lib/rider-kick.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'hashie'
 require 'rider_kick/entities/failure_details'
 require 'rider_kick/builders/abstract_active_record_entity_builder'
 require 'rider_kick/matchers/use_case_result'

data/lib/rider_kick/entities/failure_details.rb

@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require 'rider_kick/types'
@@ -7,23 +6,32 @@ require 'dry/struct'
 module RiderKick
   module Entities
     class FailureDetails < Dry::Struct
-      failure_types = Types::Strict::String.enum(
-                        'error',
-                        'expectation_failed',
-                        'not_found',
-                        'unauthorized',
-                        'unprocessable_entity'
-      )
-      attribute :type, failure_types
-      attribute :message, Types::Strict::String
+      # enum + default HARUS: default dulu, baru enum (sesuai dry-types)
+      TYPE = Types::Coercible::Symbol
+        .default(:error)
+        .enum(:error, :expectation_failed, :not_found, :unauthorized, :unprocessable_entity)
+      private_constant :TYPE
+
+      attribute :type,             TYPE
+      attribute :message,          Types::Strict::String
       attribute :other_properties, Types::Strict::Hash.default({}.freeze)
 
-      def self.from_array(array)
-        new(message: 'failure 1, failure 2', other_properties: {}, type: 'error')
+      # Kumpulkan array pesan jadi satu kalimat, type default :error
+      def self.from_array(array, type: :error, **extras)
+        new(
+          type:             type,
+          message:          Array(array).map!(&:to_s).join(', '),
+          other_properties: extras
+        )
       end
 
-      def self.from_string(string)
-        new(message: string, other_properties: {}, type: 'error')
+      # Bungkus string jadi FailureDetails, type default :error
+      def self.from_string(string, type: :error, **extras)
+        new(
+          type:             type,
+          message:          string.to_s,
+          other_properties: extras
+        )
       end
     end
   end

data/lib/rider_kick/entities/failure_details_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe RiderKick::Entities::FailureDetails do
+  it 'from_array menggabungkan pesan secara dinamis' do
+    fd = described_class.from_array(%w[alpha beta gamma])
+    expect(fd.message).to eq('alpha, beta, gamma')
+    expect(fd.type).to eq(:error)
+    expect(fd.other_properties).to eq({})
+  end
+
+  it 'from_string membungkus string menjadi FailureDetails' do
+    fd = described_class.from_string('oops')
+    expect(fd.message).to eq('oops')
+    expect(fd.type).to eq(:error)
+  end
+
+  it 'bisa dibuat dengan default type error' do
+    fd = described_class.new(message: 'X') # sengaja tanpa :type
+    expect(fd.type).to eq(:error)
+    expect(fd.other_properties).to eq({})
+  end
+end

data/lib/rider_kick/matchers/use_case_result_edge_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rider_kick/matchers/use_case_result'
+require 'dry/monads'
+
+RSpec.describe RiderKick::Matchers::UseCaseResult do
+  subject(:matcher) { described_class }
+
+  it 'melempar error untuk Failure value yang tidak didukung' do
+    weird = Object.new
+    expect {
+      matcher.call(Dry::Monads::Failure(weird)) { |m| m.failure { |_| :ok } }
+    }.to raise_error(ArgumentError, /Unexpected failure value/)
+  end
+
+  it 'meneruskan Entities::FailureDetails apa adanya' do
+    fd  = RiderKick::Entities::FailureDetails.new(message: 'boom')
+    out = nil
+
+    RiderKick::Matchers::UseCaseResult.call(Dry::Monads::Failure(fd)) do |m|
+      m.success { |_| raise 'unexpected success' }        # <- tambahkan handler success
+      m.failure { |v| out = v }
+    end
+
+    expect(out).to be_a(RiderKick::Entities::FailureDetails)
+    expect(out.message).to eq('boom')
+  end
+end

data/lib/rider_kick/use_cases/abstract_use_case_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'dry/validation'
+require 'rider_kick/use_cases/abstract_use_case'
+
+RSpec.describe RiderKick::UseCases::AbstractUseCase do
+  # Use case dummy untuk menguji .contract, .contract! dan build_parameter!
+  class DummyUseCase < RiderKick::UseCases::AbstractUseCase
+    contract do
+      params do
+        required(:name).filled(:string)
+        optional(:age).maybe(:integer)
+      end
+    end
+
+    include Dry::Monads::Do.for(:result)
+    def result
+      params = yield build_parameter!
+      Success(params)
+    end
+  end
+
+  describe '.contract/.contract!' do
+    it 'membangun dan menjalankan contract' do
+      contract = DummyUseCase.contract!(name: 'Kotaro')
+      expect(contract).to be_success
+    end
+  end
+
+  describe '#build_parameter!' do
+    it 'mengembalikan Success(Hashie::Mash) ketika valid' do
+      contract = DummyUseCase.contract!(name: 'Kotaro', age: 7)
+      use_case = DummyUseCase.new(contract)
+      result = use_case.build_parameter!
+      expect(result).to be_a(Dry::Monads::Success)
+      expect(result.value!).to respond_to(:name)
+      expect(result.value!.name).to eq('Kotaro')
+    end
+
+    it 'mengembalikan Failure(hash error) ketika tidak valid' do
+      contract = DummyUseCase.contract!(age: 'tujuh')
+      result = DummyUseCase.new(contract).build_parameter!
+      expect(result).to be_a(Dry::Monads::Failure)
+      expect(result.failure).to be_a(Hash)
+      expect(result.failure.keys).to include(:name) # name wajib
+    end
+  end
+
+  describe '#result' do
+    it 'menggunakan Do-notation dengan mulus' do
+      contract = DummyUseCase.contract!(name: 'Alam')
+      res = DummyUseCase.new(contract).result
+      expect(res).to be_success
+      expect(res.value!.name).to eq('Alam')
+    end
+  end
+end

data/lib/rider_kick/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module RiderKick
-  VERSION = '0.0.12'
+  VERSION = '0.0.13'
   public_constant :VERSION
 end