ree_lib 1.0.39 → 1.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 941b77c681e1913693fd1d61bbdb31f80a58a28c57d0449572326c00168d08f5
-  data.tar.gz: 618a3a1cb779993f53b089b53c701da7152bbc668a0e482687e44fbb5527ac57
+  metadata.gz: 312cc35a258130ad44e9158b53cf46c47309a9e835d25c0447f8596b1c3a3f99
+  data.tar.gz: b0af834f7406b9858cb278bd78f3d9e6015b7fc16a8211a72abc3b50ff64ac16
 SHA512:
-  metadata.gz: 62b8cd78d133570a809a7c7c1ecec96223f9b92ffe018fb126891b016ede11f02d2efda8d50fea34323679d621544a83422100bf075e17fe97a6360c297fd2dd
-  data.tar.gz: 321b3a88a7d74b08bd5c9ebfc7820916fede0d196c0687615033fb4d8e08b198c013502fb8b88ae131ee963f578315986c12c779b782a38e7fb6d7d242c2fb9a
+  metadata.gz: 9a8af706ff26335b51cbb87593bbe590163d425b94107317780ecf9c60176cca4c135e5ccc7c885db6065df0e4ed5215dd6a76e97f3f4e54fd03c8bcd45d482c
+  data.tar.gz: 1e477dc9a10421cdb5e8fb9b96b7068a322af007c562d8703e178330b0538f5b1006dd3fe225c029a292055990c54e644bc13ce08350b02420ea84f716cf98e4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.39)
+    ree_lib (1.0.40)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -73,6 +73,8 @@ GEM
     timecop (0.9.6)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
+    warden (1.2.9)
+      rack (>= 2.0.9)
     webmock (3.18.1)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
@@ -94,6 +96,7 @@ DEPENDENCIES
   rspec
   sqlite3 (~> 1.4.4)
   timecop (~> 0.9.5)
+  warden (~> 1.2.9)
   webmock
 
 BUNDLED WITH

data/lib/ree_lib/.vscode-ree/templates/spec_template.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 RSpec.describe :OBJECT_NAME do
   link :OBJECT_NAME, from: :PACKAGE_NAME

data/lib/ree_lib/Packages.schema.json

@@ -74,6 +74,10 @@
       "name": "ree_roda",
       "schema": "packages/ree_roda/Package.schema.json"
     },
+    {
+      "name": "ree_routes",
+      "schema": "packages/ree_routes/Package.schema.json"
+    },
     {
       "name": "ree_string",
       "schema": "packages/ree_string/Package.schema.json"

data/lib/ree_lib/packages/.vscode-ree/templates/spec_template.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 package_require('RELATIVE_FILE_PATH')
 

data/lib/ree_lib/packages/ree_actions/package/ree_actions/dsl.rb

@@ -1,101 +1,59 @@
-# frozen_string_literal: true
-
-require_relative "action_builder"
-require "uri"
-
 module ReeActions
   module DSL
     def self.included(base)
       base.extend(ClassMethods)
+      base.include(ReeMapper::DSL)
     end
 
     def self.extended(base)
       base.extend(ClassMethods)
-    end
-
-    module FactoryMethod
-      def build
-        self.class.instance_variable_get(:@actions) || []
-      end
+      base.include(ReeMapper::DSL)
     end
 
     module ClassMethods
       include Ree::Contracts::Core
       include Ree::Contracts::ArgContracts
 
-      def actions(name, &proc)
-        raise ArgumentError.new("block is required") if !block_given?
-
-        @dsl = Ree::ObjectDsl.new(
-          Ree.container.packages_facade, name, self, :object
+      def action(name, &proc)
+        dsl = Ree::ObjectDsl.new(
+          Ree.container.packages_facade, name, self, :fn
         )
 
-        @dsl.singleton
-        @dsl.factory(:build)
-        @dsl.tags(["actions"])
+        dsl.instance_exec(&proc) if block_given?
+        dsl.tags(["action"])
+        dsl.freeze(false)
+        dsl.object.set_as_compiled(false)
 
-        instance_exec(&proc)
-
-        klass = @dsl.object.klass
-        klass.send(:include, FactoryMethod)
-
-
-        Ree.container.compile(@dsl.package, name)
+        Ree.container.compile(dsl.package, name)
       end
 
-      def default_warden_scope(method_name)
-        @default_warden_scope = method_name
-      end
+      def method_added(method_name)
+        return super if method_name != :call
 
-      [:get, :post, :put, :delete, :patch, :head, :options].each do |request_method|
-        define_method request_method do |path, &proc|
-          define_action(request_method, path, &proc)
+        if @__original_call_defined
+          remove_instance_variable(:@__original_call_defined)
+          return
         end
-      end
-
-      private
 
-      contract Symbol, String, Block => ReeActions::Action
-      def define_action(request_method, path, &proc)
-        raise ArgumentError.new("actions should be called") if !@dsl
-        raise ArgumentError.new("block is required") if !block_given?
+        @__original_call_defined = true
 
-        @actions ||= []
-
-        builder = ReeActions::ActionBuilder.new
-        builder.instance_exec(&proc)
-
-        if @default_warden_scope && !builder.get_action.warden_scope
-          builder.warden_scope(@default_warden_scope)
-        end
-
-        uri = URI.parse(path) rescue nil
-
-        if uri.nil? || uri.path != path
-          raise ArgumentError.new("invalid path provided #{path}")
-        end
-
-        if uri.query && !uri.query.empty?
-          raise ArgumentError.new("action path should not include query params: #{path}")
-        end
-
-        builder.get_action.path = path
-        builder.get_action.request_method = request_method
-
-        if !builder.get_action.valid?
-          raise ArgumentError.new("action, summary and auth scope should be provider for #{builder.get_action.inspect}")
-        end
+        alias_method(:__original_call, :call)
 
-        action = builder.get_action
+        define_method :call do |user_access, attrs|
+          if self.class.const_defined?(:ActionCaster)
+            caster = self.class.const_get(:ActionCaster)
 
-        @dsl.link(action.action.name, from: action.action.package_name)
+            if !caster.respond_to?(:cast)
+              raise ArgumentError.new("ActionCaster does not respond to `cast` method")
+            end
 
-        if action.serializer
-          @dsl.link(action.serializer.name, from: action.serializer.package_name)
+            __original_call(user_access, caster.cast(attrs))
+          else
+            __original_call(user_access, attrs)
+          end
         end
 
-        @actions << action
-        action
+        nil
       end
     end
   end

data/lib/ree_lib/packages/ree_actions/package/ree_actions.rb

@@ -8,5 +8,4 @@ module ReeActions
   end
 end
 
-require_relative "ree_actions/dsl"
-require_relative "ree_actions/action_dsl"
+require_relative "ree_actions/dsl"

data/lib/ree_lib/packages/ree_actions/spec/ree_actions/dsl_spec.rb

@@ -1,93 +1,62 @@
 package_require("ree_actions/dsl")
 
 RSpec.describe ReeActions::DSL, type: [:autoclean] do
-  before :all do
+  before do
     Ree.enable_irb_mode
+  end
 
+  after do
+    Ree.disable_irb_mode
+  end
+
+  it {
     module ReeActionsTest
       include Ree::PackageDSL
 
-      package
-    end
-
-    class ReeActionsTest::EmptyActions
-      include ReeActions::DSL
-
-      actions :empty_actions do
+      package do
+        depends_on :ree_mapper
       end
-    end
 
-    class ReeActionsTest::Cmd
-      include Ree::FnDSL
+      class TestAction
+        include ReeActions::DSL
 
-      fn :cmd
+        action :test_action
 
-      def call
-      end
-    end
-
-    class ReeActionsTest::Serializer
-      include ReeMapper::DSL
-
-      mapper :serializer
+        ActionCaster = build_mapper.use(:cast) do
+          integer :user_id
+        end
 
-      build_mapper.use(:serialize) do
-        integer :id
+        contract Any, ActionCaster.dto(:cast) => Integer
+        def call(user_access, attrs)
+          attrs[:user_id]
+        end
       end
     end
 
-    class ReeActionsTest::Caster
-      include ReeMapper::DSL
+    result = ReeActionsTest::TestAction.new.call('user_access', {user_id: 1})
+    expect(result).to eq(1)
+  }
 
-      mapper :caster
+  it {
+    module ReeActionsTest
+      include Ree::PackageDSL
 
-      build_mapper.use(:cast) do
-        integer :id
+      package do
       end
-    end
 
-    class ReeActionsTest::Actions
-      include ReeActions::DSL
+      class TestAction2
+        include ReeActions::DSL
 
-      actions :actions do
-        default_warden_scope :user
-
-        post "users" do
-          summary "Test action"
-          action :cmd, from: :ree_actions_test
-          serializer :serializer, from: :ree_actions_test
-          respond_to :json
-        end
+        action :test_action2
 
-        get "files.csv" do
-          summary "Test action"
-          action :cmd, from: :ree_actions_test
-          respond_to :csv
+        contract Any, Hash => Integer
+        def call(user_access, attrs)
+          attrs[:user_id]
         end
       end
     end
-  end
-
-  after :all do
-    Ree.disable_irb_mode
-  end
-
-  it {
-    expect(ReeActionsTest::EmptyActions.new).to eq([])
-  }
-
-  it {
-    actions = ReeActionsTest::Actions.new
-
-    expect(actions.size).to eq(2)
-
-    post_action = actions.first
-    csv_action = actions.last
-
-    expect(post_action.serializer.name).to eq(:serializer)
-    expect(post_action.action.name).to eq(:cmd)
-    expect(post_action.respond_to).to eq(:json)
 
-    expect(csv_action.respond_to).to eq(:csv)
+    result = ReeActionsTest::TestAction2.new.call('user_access', {user_id: 1})
+    expect(result).to eq(1)
   }
 end

data/lib/ree_lib/packages/ree_array/spec/ree_array/functions/group_by_spec.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 package_require('ree_array/functions/group_by')
 

data/lib/ree_lib/packages/ree_array/spec/ree_array/functions/index_by_spec.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 RSpec.describe :index_by do
   link :index_by, from: :ree_array

data/lib/ree_lib/packages/ree_dao/package/ree_dao/wrappers/pg_array.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "sequel/extensions/pg_array"
+
+class ReeDao::PgArray < ReeMapper::AbstractWrapper
+  contract(
+    Any,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+    ] => Or[Sequel::Postgres::PGArray, String]
+  )
+  def db_dump(value, name:, role: nil, fields_filters: [])
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError, "`#{name}` should be an array"
+    end
+
+    value = value.map.with_index do |el, index|
+      subject.type.db_dump(
+        el,
+        name: "#{name}[#{index}]",
+        role: role,
+        fields_filters: fields_filters + [subject.fields_filter]
+      )
+    end
+
+    Sequel.pg_array(value)
+  end
+
+  contract(
+    Any,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+    ] => Array
+  ).throws(ReeMapper::TypeError)
+  def db_load(value, name:, role: nil, fields_filters: [])
+    if !value.is_a?(Sequel::Postgres::PGArray)
+      raise ReeMapper::TypeError, "`#{name}` is not Sequel::Postgres::PGArray"
+    end
+
+    value.map.with_index do |val, index|
+      subject.type.db_load(
+        val,
+        name: "#{name}[#{index}]",
+        role: role,
+        fields_filters: fields_filters + [subject.fields_filter]
+      )
+    end
+  end
+end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/wrappers/pg_jsonb.rb

@@ -0,0 +1,73 @@
+require "sequel/extensions/pg_json"
+
+package_require("ree_object/functions/to_hash")
+
+class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
+  contract(
+    Any,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+    ] => Or[
+      Sequel::Postgres::JSONBHash,
+      Sequel::Postgres::JSONBArray,
+      Sequel::Postgres::JSONBInteger,
+      Sequel::Postgres::JSONBTrue,
+      Sequel::Postgres::JSONBFalse,
+      Sequel::Postgres::JSONBString,
+      Sequel::Postgres::JSONBFloat,
+      Sequel::Postgres::JSONBNull
+    ]
+  ).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil, fields_filters: [])
+    value = subject.type.db_dump(
+      value,
+      name: name,
+      role: role,
+      fields_filters: fields_filters + [subject.fields_filter]
+    )
+
+    begin
+      Sequel.pg_jsonb_wrap(value)
+    rescue Sequel::Error
+      raise ReeMapper::TypeError, "`#{name}` should be an jsonb primitive"
+    end
+  end
+
+  contract(
+    Any,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+    ] => Or[
+      Hash,
+      Array,
+      Integer,
+      Float,
+      String,
+      Bool,
+      NilClass
+    ]
+  ).throws(ReeMapper::TypeError)
+  def db_load(value, name:, role: nil, fields_filters: [])
+    value = case value
+    when Sequel::Postgres::JSONBHash
+      ReeObject::ToHash.new.call(value.to_h)
+    when Sequel::Postgres::JSONBArray
+      ReeObject::ToHash.new.call(value.to_a)
+    when Numeric, String, TrueClass, FalseClass, NilClass
+      value
+    else
+      raise ReeMapper::TypeError, "`#{name}` is not Sequel::Postgres::JSONB"
+    end
+
+    subject.type.db_load(
+      value,
+      name: name,
+      role: role,
+      fields_filters: fields_filters + [subject.fields_filter]
+    )
+  end
+end

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/build_sqlite_connection_spec.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 package_require('ree_dao')
 package_require('ree_dto/entity_dsl')

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/one_to_many_spec.rb

@@ -1,9 +1,9 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 RSpec.describe :one_to_many do
+  link :build_sqlite_connection, from: :ree_dao
   link :one_to_many, from: :ree_dao
   link :persist_assoc, from: :ree_dao
-  link :build_sqlite_connection, from: :ree_dao
 
   let(:connection) { build_sqlite_connection({database: 'sqlite_db'}) }
 

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/one_to_one_spec.rb

@@ -1,9 +1,9 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 RSpec.describe :one_to_one do
+  link :build_sqlite_connection, from: :ree_dao
   link :one_to_one, from: :ree_dao
   link :persist_assoc, from: :ree_dao
-  link :build_sqlite_connection, from: :ree_dao
 
   let(:connection) { build_sqlite_connection({database: 'sqlite_db'}) }
 

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/persist_assoc_spec.rb

@@ -1,8 +1,8 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 RSpec.describe :persist_assoc do
-  link :persist_assoc, from: :ree_dao
   link :build_sqlite_connection, from: :ree_dao
+  link :persist_assoc, from: :ree_dao
 
   let(:connection) { build_sqlite_connection({database: 'sqlite_db'}) }
 

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/wrappers/pg_array_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+package_require("ree_dao/wrappers/pg_array")
+
+RSpec.describe 'ReeDao::PgArray' do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast),
+        build_mapper_strategy(method: :serialize),
+        build_mapper_strategy(method: :db_dump, dto: Hash),
+        build_mapper_strategy(method: :db_load, dto: Hash, always_optional: true)
+      ]
+    ).register_wrapper(:pg_array, ReeDao::PgArray)
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:db_dump).use(:db_load) do
+      pg_array? :tags, integer
+      pg_array? :keys, string
+    end
+  }
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump({
+        tags: [1, 2],
+        keys: ["a", "b"]
+      })).to eq({
+        tags: [1, 2],
+        keys: ["a", "b"]
+      })
+    }
+
+    it {
+      expect {
+        mapper.db_dump({ tags: 1 })
+      }.to raise_error(ReeMapper::TypeError, "`tags` should be an array")
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({
+        tags: Sequel::Postgres::PGArray.new([1, 2]),
+        keys: Sequel::Postgres::PGArray.new(["a", "b"])
+      })).to eq({
+        tags: [1, 2],
+        keys: ["a", "b"]
+      })
+    }
+
+    it {
+      expect {
+        mapper.db_load({
+          tags: 1
+        })
+      }.to raise_error(ReeMapper::TypeError, "`tags` is not Sequel::Postgres::PGArray")
+    }
+  end
+end

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/wrappers/pg_jsonb_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+package_require("ree_dao/wrappers/pg_jsonb")
+
+RSpec.describe 'ReeDao::PgJsonb' do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast),
+        build_mapper_strategy(method: :serialize),
+        build_mapper_strategy(method: :db_dump, dto: Hash),
+        build_mapper_strategy(method: :db_load, dto: Hash, always_optional: true)
+      ]
+    ).register_wrapper(:pg_jsonb, ReeDao::PgJsonb)
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:db_dump).use(:db_load) do
+      pg_jsonb? :payload do
+        string :key
+      end
+      pg_jsonb? :numbers, array(integer)
+      pg_jsonb? :figures, (array do
+        string :coords
+      end)
+      pg_jsonb? :number, integer
+      pg_jsonb? :boolean, bool
+      pg_jsonb? :any, any
+    end
+  }
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump({
+        payload: { key: 'key' },
+        numbers: [1, 2],
+        figures: [{ coords: 'x=1,y=1' }],
+        number: 1,
+        boolean: true
+      })).to eq({
+        payload: { key: 'key' },
+        numbers: [1, 2],
+        figures: [{ coords: 'x=1,y=1' }],
+        number: 1,
+        boolean: true
+      })
+    }
+
+    it {
+      expect {
+        mapper.db_dump({ numbers: ['1'] })
+      }.to raise_error(ReeMapper::TypeError, "`numbers[0]` should be an integer")
+    }
+
+    it {
+      expect {
+        mapper.db_dump({ any: Object.new })
+      }.to raise_error(ReeMapper::TypeError, "`any` should be an jsonb primitive")
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({
+        payload: Sequel::Postgres::JSONBHash.new({ key: 'key' }),
+        numbers: Sequel::Postgres::JSONBArray.new([1, 2]),
+        figures: Sequel::Postgres::JSONBArray.new([{ coords: 'x=1,y=1' }]),
+        number: 1,
+        boolean: true
+      })).to eq({
+        payload: { key: 'key' },
+        numbers: [1, 2],
+        figures: [{ coords: 'x=1,y=1' }],
+        number: 1,
+        boolean: true
+      })
+    }
+
+    it {
+      expect {
+        mapper.db_load({ numbers: Sequel::Postgres::JSONBArray.new([1.1]) })
+      }.to raise_error(ReeMapper::TypeError, "`numbers[0]` should be an integer")
+    }
+
+    it {
+      expect {
+        mapper.db_load({ numbers: Object.new })
+      }.to raise_error(ReeMapper::TypeError, "`numbers` is not Sequel::Postgres::JSONB")
+    }
+  end
+end

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/in_default_time_zone_spec.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal = true
+# frozen_string_literal: true
 
 RSpec.describe :in_default_time_zone do
   link :in_default_time_zone, from: :ree_datetime