ree_lib 1.0.0

data/lib/ree_lib/packages/ree_dao/package/ree_dao/dataset_extensions.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module ReeDao
+  module DatasetExtensions
+    def self.included(base)
+      alias_methods(base)
+      base.include(InstanceMethods)
+    end
+
+    def self.extended(base)
+      alias_methods(base)
+      base.include(InstanceMethods)
+    end
+
+    def self.alias_methods(base)
+      [:all, :update, :delete, :first, :last].each do |m|
+        base.alias_method(:"__original_#{m}", m)
+      end
+    end
+
+    module InstanceMethods
+      PERSISTENCE_STATE_VARIABLE = :@persistence_state
+      IMPORT_BATCH_SIZE = 1000
+
+      # override methods
+      def find(id, mode = :write, mapper: nil)
+        where(primary_key => id).first(mode, mapper: mapper)
+      end
+
+      def first(mode = :write, mapper: nil)
+        with_mapper(mode, mapper).__original_first
+      end
+
+      def last(mode = :write, mapper: nil)
+        with_mapper(mode, mapper).__original_last
+      end
+
+      def all(mode = :write, mapper: nil)
+        with_mapper(mode, mapper).__original_all
+      end
+
+      def delete_all
+        where({}).__original_delete
+      end
+
+      def put(entity)
+        raw = opts[:schema_mapper].db_dump(entity)
+        remove_null_primary_key(raw)
+        key = insert(raw)
+
+        set_entity_primary_key(entity, raw, key)
+        set_persistence_state(entity, raw)
+
+        entity
+      end
+
+      def put_with_conflict(entity, opts = {})
+        raw = opts[:schema_mapper].db_dump(entity)
+        remove_null_primary_key(raw)
+
+        if opts.key?(:update) && opts[:update].empty?
+          opts.delete(:update)
+        elsif opts[:update].is_a?(Array)
+          update = {}
+
+          opts[:update].each do |column|
+            update[column] = raw[column]
+          end
+
+          opts[:update] = update
+        end
+
+        key = insert_conflict(opts).insert(raw)
+
+        set_entity_primary_key(entity, raw, key)
+        set_persistence_state(entity, raw)
+
+        where(primary_key => key).first
+      end
+
+      def import_all(entities, batch_size: IMPORT_BATCH_SIZE)
+        return if entities.empty?
+
+        mapper = opts[:schema_mapper]
+        columns = columns
+        raw = {}
+
+        columns.delete(:id)
+        columns.delete(:row)
+
+        data = entities.map do |entity|
+          hash = mapper.to_hash(entity)
+          raw[entity] = hash
+
+          columns.map { hash[_1] }
+        end
+
+        ids = import(
+          columns, data, slice: batch_size, return: :primary_key
+        )
+
+        ids.each_with_index do |id, index|
+          entity = entities[index]
+          raw_data = raw[entity]
+
+          set_entity_primary_key(entity, raw_data, id)
+          set_persistence_state(entity, raw_data)
+        end
+
+        nil
+      end
+
+      def update(entity)
+        raw = opts[:schema_mapper].db_dump(entity)
+        raw = extract_changes(entity, raw)
+
+        unless raw.empty?
+          update_persistence_state(entity, raw)
+          key_condition = prepare_key_condition_from_entity(entity)
+          where(key_condition).__original_update(raw)
+        end
+
+        entity
+      end
+
+      def delete(entity = nil)
+        if entity
+          key_condition = prepare_key_condition_from_entity(entity)
+          where(key_condition).__original_delete
+        else
+          __original_delete
+        end
+      end
+
+      def with_lock
+        for_update
+      end
+
+      private
+
+      def primary_key
+        opts[:primary_key] || :id
+      end
+
+      def remove_null_primary_key(raw)
+        return if primary_key.is_a?(Array)
+
+        if raw.has_key?(primary_key) && raw[primary_key].nil?
+          raw.delete(primary_key)
+        else
+          str_key = primary_key.to_s
+
+          if raw.has_key?(str_key) && raw[str_key].nil?
+            raw.delete(str_key)
+          end
+        end
+      end
+
+      def with_mapper(mode, mapper)
+        clone(
+          mode: mode, schema_mapper: mapper || opts[:schema_mapper],
+        ).with_row_proc(
+          Proc.new { |hash|
+            m = mapper || opts[:schema_mapper]
+
+            if m
+              entity = m.db_load(hash)
+
+              if mode == :write
+                self.set_persistence_state(entity, hash)
+              end
+
+              entity
+            else
+              hash
+            end
+          }
+        )
+      end
+
+      def extract_changes(entity, hash)
+        return hash unless entity.instance_variable_defined?(PERSISTENCE_STATE_VARIABLE)
+        changes = {}
+
+        persistence_state = entity.instance_variable_get(PERSISTENCE_STATE_VARIABLE)
+
+        hash.each do |column, value|
+          previous_column_value = persistence_state[column]
+
+          if persistence_state.has_key?(column) && previous_column_value != value
+            changes[column] = value
+          end
+        end
+
+        changes
+      end
+
+      def set_persistence_state(entity, raw)
+        if !entity.is_a?(Integer) && !entity.is_a?(Symbol)
+          entity.instance_variable_set(PERSISTENCE_STATE_VARIABLE, raw)
+        end
+      end
+
+      def update_persistence_state(entity, raw)
+        persistence_state = entity.instance_variable_get(PERSISTENCE_STATE_VARIABLE)
+
+        if persistence_state
+          persistence_state.merge!(raw)
+        end
+      end
+
+      def set_entity_primary_key(entity, raw, key)
+        if key && !primary_key.is_a?(Array)
+          entity.instance_variable_set("@#{primary_key}", key)
+          raw[primary_key] = key
+        end
+      end
+
+      def prepare_key_condition_from_entity(entity)
+        key_condition = {}
+
+        if primary_key.is_a?(Array)
+          primary_key.each do |key_part|
+            key_part_value = entity.send(key_part)
+            raise ArgumentError, "entity's primary key can't be nil, got nil for #{key_part}" unless key_part_value
+
+            key_part_value = key_part_value.number if key_part_value.is_a?(ReeEnum::Value)
+            key_condition[key_part] = key_part_value
+          end
+        elsif primary_key.is_a?(Symbol)
+          key_value = entity.send(primary_key)
+          raise ArgumentError, "entity's primary key can't be nil, got nil for #{primary_key}" unless key_value
+
+          key_condition[primary_key] = key_value
+        else
+          raise StandardError, "primary key should be array or symbol"
+        end
+
+        key_condition
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+package_require('ree_string/functions/underscore')
+
+module ReeDao::DSL
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.include(InstanceMethods)
+  end
+
+  def self.extended(base)
+    base.extend(ClassMethods)
+    base.include(InstanceMethods)
+  end
+
+  module InstanceMethods
+    def build
+      dataset_class = db.dataset_class
+      klass = Class.new(dataset_class)
+      filters = self.class.instance_variable_get(:@filters) || []
+
+      filters.each do |filter|
+        klass.define_method(filter.name, &filter.proc)
+      end
+
+      db.dataset_class = klass
+
+      dao = build_dao(
+        connection: db,
+        table_name: self.class.instance_variable_get(:@table),
+        mapper: self.class.instance_variable_get(:@schema_mapper) || (raise Ree::Error.new("Dao schema mapper is not set. Use `schema` DSL to define it", :invalid_dsl_usage)),
+        primary_key: self.class.instance_variable_get(:@primary_key),
+        default_select_columns: self.class.instance_variable_get(:@default_select_columns),
+      )
+
+      db.dataset_class = dataset_class
+
+      dao
+    end
+  end
+
+  module ClassMethods
+    include Ree::Contracts::Core
+    include Ree::Contracts::ArgContracts
+
+    contract Symbol, Block => Ree::Object
+    def dao(name, &proc)
+      if !block_given?
+        raise Ree::Error.new("dao requires block to link specific db connection as :db => link :some_db, as: :db", :invalid_dsl_usage)
+      end
+
+      dsl = Ree::ObjectDsl.new(
+        Ree.container.packages_facade, name, self, :object
+      )
+
+      dsl.instance_exec(&proc)
+
+      db_link = dsl.object.links.detect { _1.as == :db }
+
+      if !db_link
+        raise Ree::Error.new("dao should link specific db connection as :db => link :some_db, as: :db", :invalid_dsl_usage)
+      end
+
+      if dsl.object.factory? && dsl.object.factory != :build
+        raise Ree::Error.new("dao DSL automatically assigns `factory :build` to object. Custom factory methods are not supported", :invalid_dsl_usage)
+      end
+
+      dsl.link(:build_dao, from: :ree_dao)
+      dsl.factory(:build)
+      dsl.singleton
+
+      # automatically assign table name from object class
+      table(
+        ReeString::Underscore.new
+          .call(self.name.split("::").last.gsub(/dao$/i, ''))
+          .to_sym
+      )
+
+      Ree.container.compile(dsl.package, name)
+    end
+
+    contract Symbol => Symbol
+    def table(table_name)
+      @table = table_name
+    end
+
+    contract Or[Symbol, ArrayOf[Symbol]] => nil
+    def primary_key(primary_key)
+      @primary_key = primary_key
+      nil
+    end
+
+    contract ArrayOf[Symbol] => nil
+    def default_select_columns(columns)
+      @default_select_columns = columns
+      nil
+    end
+
+    contract(Class, Block => nil)
+    def schema(dto_class, &proc)
+      mapper_factory = ReeMapper.get_mapper_factory(
+        Object.const_get(self.name.split('::').first)
+      )
+
+      mapper = mapper_factory
+        .call
+        .use(:db_dump)
+        .use(:db_load, dto: dto_class, &proc)
+
+      self.instance_variable_set(:@schema_mapper, mapper)
+      nil
+    end
+
+    DaoFilter = Struct.new(:name, :proc)
+
+    contract Symbol, Proc => nil
+    def filter(name, proc)
+      filters = self.instance_variable_get(:@filters)
+
+      if filters.nil?
+        filters = []
+        self.instance_variable_set(:@filters, filters)
+      end
+
+      filters.push(DaoFilter.new(name, proc))
+
+      nil
+    end
+  end
+end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_connection.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'logger'
+require 'timeout'
+
+class ReeDao::BuildConnection
+  include Ree::FnDSL
+
+  fn :build_connection do
+    link :connections
+    link 'ree_dao/dataset_extensions', -> { DatasetExtensions }
+  end
+
+  TIMEZONES = [:utc, :local].freeze
+
+  DEFAULTS = {
+    datetime_class: DateTime,
+    database_timezone: :utc,
+    application_timezone: :utc,
+    typecast_timezone: :utc,
+    connection_validation_timeout: 60,
+    single_threaded: false,
+    timeout: 90
+  }.freeze
+
+  contract(
+    Hash,
+    Ksplat[
+      timeout?: Integer,
+      convert_two_digit_years?: Bool,
+      single_threaded?: Bool,
+      extensions?: ArrayOf[Symbol],
+      datetime_class?: Or[Time, DateTime],
+      after_connect?: Proc,
+      database_timezone?: Or[*TIMEZONES],
+      application_timezone?: Or[*TIMEZONES],
+      typecast_timezone?: Or[*TIMEZONES],
+      connection_validation_timeout?: Integer,
+      logger?: Logger,
+      sql_log_level?: [:fatal, :error, :warn, :info, :debug],
+    ] => Any
+  )
+  def call(conn_opts, **opts)
+    opts = DEFAULTS.merge(opts.dup)
+
+    database_timezone = opts.delete(:database_timezone)
+    application_timezone = opts.delete(:application_timezone)
+    typecast_timezone = opts.delete(:typecast_timezone)
+    # connection_validation_timeout = opts.delete(:connection_validation_timeout)
+    convert_two_digit_years = opts.delete(:convert_two_digit_years)
+    single_threaded = opts.delete(:single_threaded)
+    datetime_class = opts.delete(:datetime_class)
+    extensions = opts.delete(:extensions) || []
+    timeout = opts.delete(:timeout)
+
+    Sequel.database_timezone = database_timezone
+    Sequel.application_timezone = application_timezone
+    Sequel.typecast_timezone = typecast_timezone
+    Sequel.single_threaded = single_threaded
+    Sequel.convert_two_digit_years = convert_two_digit_years if convert_two_digit_years
+    Sequel.datetime_class = datetime_class
+
+    connection = Sequel.connect(conn_opts)
+
+    if opts[:logger]
+      connection.logger = opts[:logger]
+    end
+
+    if opts[:sql_log_level]
+      connection.sql_log_level = opts[:sql_log_level] 
+    end
+
+    Timeout::timeout(timeout) do
+      loop do
+        begin
+          connection.test_connection
+          break
+        rescue => e
+          puts("Unable to establish DB connection: #{conn_opts.inspect}")
+          puts(e.inspect)
+          sleep(1)
+        end
+      end
+    end
+
+    # connection.pool.connection_validation_timeout = connection_validation_timeout if connection_validation_timeout
+
+    extensions.each { connection.extension(_1) }
+    connections.add(connection)
+
+    dataset_class = connection.dataset_class
+    klass = Class.new(dataset_class)
+    klass.extend(ReeDao::DatasetExtensions)
+
+    connection.dataset_class = klass
+
+    connection
+  rescue => e
+    connection&.disconnect
+    raise e
+  end
+end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_dao.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class ReeDao::BuildDao
+  include Ree::FnDSL
+
+  fn :build_dao
+
+  contract(
+    Kwargs[
+      connection: Any,
+      table_name: Symbol,
+      mapper: -> (v) { v.class.ancestors.include?(ReeMapper::Mapper) }
+    ],
+    Ksplat[
+      primary_key?: Nilor[Or[Symbol, ArrayOf[Symbol]]],
+      default_select_columns?: Nilor[ArrayOf[Symbol]],
+    ] => Any
+  )
+  def call(connection:, table_name:, mapper:, **opts)
+    connection[table_name].clone(
+      mode: :write,
+      schema_mapper: mapper,
+      primary_key: opts[:primary_key] || :id
+    )
+  end
+end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_pg_connection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class ReeDao::BuildPgConnection
+  include Ree::FnDSL
+
+  fn :build_pg_connection do
+    link :build_connection
+  end
+
+  contract(
+    {
+      conn_str?: String,
+      adapter: String,
+      database?: String,
+      encoding?: String,
+      user?: String,
+      password?: String,
+      host?: String,
+      port?: String,
+      convert_infinite_timestamps?: Or[:string, :nil, :float],
+      connect_timeout?: Integer,
+      driver_options?: Hash,
+      notice_receiver?: Proc,
+      sslmode?: Or['disable', 'allow', 'prefer', 'require', 'verify-ca', 'verify-full'],
+      sslrootcert?: String,
+      search_path?: String,
+      use_iso_date_format?: Bool,
+    },
+    Ksplat[
+      RestKeys => Any # inherited from `build_connection` opts
+    ] => Sequel::Database
+  )
+  def call(conn_opts, **opts)
+    require 'sequel/adapters/postgres'
+    build_connection(conn_opts, **opts)
+  end
+end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/build_sqlite_connection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+
+class ReeDao::BuildSqliteConnection
+  include Ree::FnDSL
+
+  fn :build_sqlite_connection do
+    link :build_connection
+  end
+
+  contract(
+    {
+      database: String,
+      readonly?: Bool,
+      timeout?: Integer,
+    },
+    Ksplat[
+      RestKeys => Any # inherited from `build_connection` opts
+    ] => Sequel::Database
+  )
+  def call(conn_opts, **opts)
+    require 'sequel/adapters/sqlite'
+    build_connection(conn_opts.merge(adapter: 'sqlite'), **opts)
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "sequel"
+
+module ReeDao
+  include Ree::PackageDSL
+
+  package do
+    depends_on :ree_mapper
+    depends_on :ree_string
+    depends_on :ree_enum
+    depends_on :ree_dto
+  end
+
+  require_relative "./ree_dao/dsl"
+end

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/beans/connections.schema.json

@@ -0,0 +1,15 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "connections",
+  "path": "packages/ree_dao/package/ree_dao/beans/connections.rb",
+  "mount_as": "object",
+  "class": "ReeDao::Connections",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/build_connection.schema.json

@@ -0,0 +1,38 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "build_connection",
+  "path": "packages/ree_dao/package/ree_dao/functions/build_connection.rb",
+  "mount_as": "fn",
+  "class": "ReeDao::BuildConnection",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Any",
+      "args": [
+        {
+          "arg": "conn_opts",
+          "type": "Hash"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:timeout? => Integer, :convert_two_digit_years? => Bool, :single_threaded? => Bool, :extensions? => ArrayOf[Symbol], :datetime_class? => Or[Time, DateTime], :after_connect? => Proc, :database_timezone? => Or[utc, local], :application_timezone? => Or[utc, local], :typecast_timezone? => Or[utc, local], :connection_validation_timeout? => Integer, :logger? => Logger, :sql_log_level? => [fatal, error, warn, info, debug]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "connections",
+      "package_name": "ree_dao",
+      "as": "connections",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/build_dao.schema.json

@@ -0,0 +1,39 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "build_dao",
+  "path": "packages/ree_dao/package/ree_dao/functions/build_dao.rb",
+  "mount_as": "fn",
+  "class": "ReeDao::BuildDao",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Any",
+      "args": [
+        {
+          "arg": "connection",
+          "type": "Any"
+        },
+        {
+          "arg": "table_name",
+          "type": "Symbol"
+        },
+        {
+          "arg": "mapper",
+          "type": "Proc#call"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:primary_key? => Nilor[Or[Symbol, ArrayOf[Symbol]]], :default_select_columns? => Nilor[ArrayOf[Symbol]]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}