couchbase-orm 1.1.1 → 2.0.2

data/lib/couchbase-orm/proxies/results_proxy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+module CouchbaseOrm
+    class ResultsProxy
+        def initialize(proxyfied)
+            @proxyfied = proxyfied
+            
+            raise ArgumentError, "Proxyfied object must respond to :to_a" unless @proxyfied.respond_to?(:to_a)
+
+            proxyfied.public_methods.each do |method|
+                next if self.public_methods.include?(method)
+
+                self.class.define_method(method) do |*params, &block|
+                    @proxyfied.send(method, *params, &block)
+                end
+            end
+        end
+        
+        def method_missing(m, *args, &block)
+            @proxyfied.to_a.send(m, *args, &block)
+        end
+    end
+end

data/lib/couchbase-orm/railtie.rb

@@ -23,9 +23,8 @@ require 'couchbase-orm/base'
 module Rails #:nodoc:
     module Couchbase #:nodoc:
         class Railtie < Rails::Railtie #:nodoc:
-
-            config.couchbase = ActiveSupport::OrderedOptions.new
-            config.couchbase.ensure_design_documents = true
+            config.couchbase_orm = ActiveSupport::OrderedOptions.new
+            config.couchbase_orm.ensure_design_documents = true
 
             # Maping of rescued exceptions to HTTP responses
             #
@@ -35,10 +34,6 @@ module Rails #:nodoc:
             # @return [Hash] rescued responses
             def self.rescue_responses
                 {
-                    'Libcouchbase::Error::KeyNotFound' => :not_found,
-                    'Libcouchbase::Error::NotStored' => :unprocessable_entity,
-                    Libcouchbase::Error::KeyNotFound => :not_found,
-                    Libcouchbase::Error::NotStored => :unprocessable_entity
                 }
             end
 
@@ -48,14 +43,8 @@ module Rails #:nodoc:
                 config.action_dispatch.rescue_responses.merge!(rescue_responses)
             end
 
-            # Initialize Couchbase Mode. This will look for a couchbase.yml in the
-            # config directory and configure Couchbase connection appropriately.
-            initializer 'couchbase.setup_connection' do
-                config_file = Rails.root.join('config', 'couchbase.yml')
-                if config_file.file? &&
-                    config = YAML.load(ERB.new(File.read(config_file)).result)[Rails.env]
-                    ::CouchbaseOrm::Connection.options = config.deep_symbolize_keys
-                end
+            initializer 'couchbase_orm.setup_connection_config' do
+                CouchbaseOrm::Connection.config = Rails.application.config_for(:couchbase)
             end
 
             # After initialization we will warn the user if we can't find a couchbase.yml and
@@ -83,12 +72,12 @@ module Rails #:nodoc:
 
             # Check (and upgrade if needed) all design documents
             config.after_initialize do |app|
-                if config.couchbase.ensure_design_documents
+                if config.couchbase_orm.ensure_design_documents
                     begin
                         ::CouchbaseOrm::Base.descendants.each do |model|
                             model.ensure_design_document!
                         end
-                    rescue ::Libcouchbase::Error::Timedout, ::Libcouchbase::Error::ConnectError, ::Libcouchbase::Error::NetworkError
+                    rescue ::MTLibcouchbase::Error::Timedout, ::MTLibcouchbase::Error::ConnectError, ::MTLibcouchbase::Error::NetworkError
                         # skip connection errors for now
                     end
                 end

data/lib/couchbase-orm/relation.rb

@@ -0,0 +1,249 @@
+module CouchbaseOrm
+    module Relation
+        extend ActiveSupport::Concern
+
+        class CouchbaseOrm_Relation
+            def initialize(model:, where: where = nil, order: order = nil, limit: limit = nil, _not: _not = false, strict_loading: strict_loading = false)
+                CouchbaseOrm::logger.debug "CouchbaseOrm_Relation init: #{model} where:#{where.inspect} not:#{_not.inspect} order:#{order.inspect} limit: #{limit} strict_loading: #{strict_loading}"
+                @model = model
+                @limit = limit
+                @where = []
+                @order = {}
+                @order = merge_order(**order) if order
+                @where = merge_where(where, _not) if where
+                @strict_loading = strict_loading
+                CouchbaseOrm::logger.debug "- #{to_s}"
+            end
+
+            def to_s
+                "CouchbaseOrm_Relation: #{@model} where:#{@where.inspect} order:#{@order.inspect} limit: #{@limit} strict_loading: #{@strict_loading}"
+            end
+
+            def to_n1ql
+                bucket_name = @model.bucket.name
+                where = build_where
+                order = build_order
+                limit = build_limit
+                "select raw meta().id from `#{bucket_name}` where #{where} order by #{order} #{limit}"
+            end
+
+            def execute(n1ql_query)
+                result = @model.cluster.query(n1ql_query, Couchbase::Options::Query.new(scan_consistency: CouchbaseOrm::N1ql.config[:scan_consistency]))
+                CouchbaseOrm.logger.debug { "Relation query: #{n1ql_query} return #{result.rows.to_a.length} rows with scan_consistency : #{CouchbaseOrm::N1ql.config[:scan_consistency]}" }
+                N1qlProxy.new(result)
+            end
+
+            def query
+                CouchbaseOrm::logger.debug("Query: #{self}")
+                n1ql_query = to_n1ql
+                execute(n1ql_query)
+            end
+            
+            def update_all(**cond)
+                bucket_name = @model.bucket.name
+                where = build_where
+                limit = build_limit
+                update = build_update(**cond)
+                n1ql_query = "update `#{bucket_name}` set #{update} where #{where} #{limit}"
+                execute(n1ql_query)
+            end
+
+            def ids
+                query.to_a
+            end
+
+            def strict_loading
+                CouchbaseOrm_Relation.new(**initializer_arguments.merge(strict_loading: true))
+            end
+
+            def strict_loading?
+                !!@strict_loading
+            end
+
+            def first
+                result = @model.cluster.query(self.limit(1).to_n1ql, Couchbase::Options::Query.new(scan_consistency: CouchbaseOrm::N1ql.config[:scan_consistency]))
+                return unless (first_id = result.rows.to_a.first)
+
+                @model.find(first_id, with_strict_loading: @strict_loading)
+            end
+
+            def last
+                result = @model.cluster.query(to_n1ql, Couchbase::Options::Query.new(scan_consistency: CouchbaseOrm::N1ql.config[:scan_consistency]))
+                last_id = result.rows.to_a.last
+                @model.find(last_id, with_strict_loading: @strict_loading) if last_id
+            end
+
+            def count
+                query.count
+            end
+
+            def empty?
+                limit(1).count == 0
+            end
+
+            def pluck(*fields)
+                map do |model|
+                    if fields.length == 1
+                        model.send(fields.first)
+                    else
+                        fields.map do |field|
+                            model.send(field)
+                        end
+                    end
+                end
+            end
+
+            alias :size :count
+            alias :length :count
+
+            def to_ary
+                ids = query.results
+                return [] if ids.empty?
+                Array(ids && @model.find(ids, with_strict_loading: @strict_loading))
+            end
+
+            alias :to_a :to_ary
+
+            delegate :each, :map, :collect, :find, :filter, :reduce, :to => :to_ary
+
+            def [](*args)
+                to_ary[*args]
+            end
+
+            def delete_all
+                CouchbaseOrm::logger.debug{ "Delete all: #{self}" }
+                ids = query.to_a
+                CouchbaseOrm::Connection.bucket.default_collection.remove_multi(ids) unless ids.empty?
+            end
+
+            def where(string_cond=nil, **conds)
+                CouchbaseOrm_Relation.new(**initializer_arguments.merge(where: merge_where(conds)+string_where(string_cond)))
+            end
+
+            def find_by(**conds)
+                CouchbaseOrm_Relation.new(**initializer_arguments.merge(where: merge_where(conds))).first
+            end
+
+            def not(**conds)
+                CouchbaseOrm_Relation.new(**initializer_arguments.merge(where: merge_where(conds, _not: true)))
+            end
+
+            def order(*lorder, **horder)
+                CouchbaseOrm_Relation.new(**initializer_arguments.merge(order: merge_order(*lorder, **horder)))
+            end
+
+            def limit(limit)
+                CouchbaseOrm_Relation.new(**initializer_arguments.merge(limit: limit))
+            end
+
+            def all
+                CouchbaseOrm_Relation.new(**initializer_arguments)
+            end
+
+            def scoping
+                scopes = (Thread.current[@model.name] ||= [])
+                scopes.push(self)
+                result = yield
+            ensure
+                scopes.pop
+                result
+            end
+
+            private
+
+            def build_limit
+                @limit ? "limit #{@limit}" : ""
+            end
+
+            def initializer_arguments
+                { model: @model, order: @order, where: @where, limit: @limit, strict_loading: @strict_loading }
+            end
+
+            def merge_order(*lorder, **horder)
+                raise ArgumentError, "invalid order passed by list: #{lorder.inspect}, must be symbols" unless lorder.all? { |o| o.is_a? Symbol }
+                raise ArgumentError, "Invalid order passed by hash: #{horder.inspect}, must be symbol -> :asc|:desc" unless horder.all? { |k, v| k.is_a?(Symbol) && [:asc, :desc].include?(v) }
+                @order
+                    .merge(Array.wrap(lorder).map{ |o| [o, :asc] }.to_h)
+                    .merge(horder)
+            end
+     
+            def merge_where(conds, _not = false)
+                @where + (_not ? conds.to_a.map{|k,v|[k,v,:not]} : conds.to_a)
+            end
+
+            def string_where(string_cond, _not = false)
+                return [] unless string_cond
+                cond = "(#{string_cond})"
+                [(_not ? [nil, cond, :not] : [nil, cond])]
+            end
+
+            def build_order
+                order = @order.map do |key, value|
+                    "#{key} #{value}"
+                end.join(", ")
+                order.empty? ? "meta().id" : order
+            end
+            
+            def build_where
+                build_conds([[:type, @model.design_document]] + @where)
+            end
+
+            def build_conds(conds)
+                conds.map do |key, value, opt|
+                    if key
+                        opt == :not ? 
+                            @model.build_not_match(key, value) : 
+                            @model.build_match(key, value)
+                    else
+                        value
+                    end
+                end.join(" AND ")
+            end
+
+            def build_update(**cond)
+                cond.map do |key, value|
+                    for_clause=""
+                    if value.is_a?(Hash) && value[:_for]
+                        path_clause = value.delete(:_for)
+                        var_clause = path_clause.to_s.split(".").last.singularize
+                        
+                        _when = value.delete(:_when)
+                        when_clause = _when ? build_conds(_when.to_a) : ""
+                        
+                        _set = value.delete(:_set)                       
+                        value = _set if _set
+
+                        for_clause = " for #{var_clause} in #{path_clause} when #{when_clause} end"
+                    end
+                    if value.is_a?(Hash)
+                        value.map do |k, v|
+                            "#{key}.#{k} = #{v}"
+                        end.join(", ") + for_clause
+                    else
+                        "#{key} = #{@model.quote(value)}#{for_clause}"
+                    end
+                end.join(", ")
+            end
+
+            def method_missing(method, *args, &block)
+                if @model.respond_to?(method)
+                    scoping {
+                        @model.public_send(method, *args, &block)
+                    }
+                else
+                    super
+                end
+            end
+        end
+
+        module ClassMethods
+            def relation
+                Thread.current[self.name]&.last || CouchbaseOrm_Relation.new(model: self)
+            end
+
+            delegate :ids, :update_all, :delete_all, :count, :empty?, :filter, :reduce, :find_by, to: :all
+
+            delegate :where, :not, :order, :limit, :all, :strict_loading, :strict_loading?, to: :relation
+        end
+    end
+end

data/lib/couchbase-orm/strict_loading.rb

@@ -0,0 +1,21 @@
+module CouchbaseOrm
+  module StrictLoading
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :strict_loading_by_default, instance_accessor: false, default: false
+    end
+
+    def init_strict_loading
+      @strict_loading = self.class.strict_loading_by_default
+    end
+
+    def strict_loading!
+      @strict_loading = true
+    end
+
+    def strict_loading?
+      !!@strict_loading
+    end
+  end
+end

data/lib/couchbase-orm/timestamps/created.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CouchbaseOrm
+  module Timestamps
+    # This module handles the behavior for setting up document created at
+    # timestamp.
+    module Created
+      extend ActiveSupport::Concern
+
+      included do
+        set_callback :create, :before, -> {
+          return if created_at
+
+          time = Time.current
+          self.created_at = time
+        }, if: -> { attributes.has_key?('created_at')}
+      end
+    end
+  end
+end

data/lib/couchbase-orm/timestamps/updated.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CouchbaseOrm
+  module Timestamps
+    # This module handles the behavior for setting up document updated at
+    # timestamp.
+    module Updated
+      extend ActiveSupport::Concern
+
+      included do
+        set_callback :save, :before, -> {
+          return if frozen?
+          return unless changed? || new_record?
+
+          time = Time.current
+          self.updated_at = time if !updated_at_changed?
+        }, if: -> { attributes.has_key? 'updated_at' }
+      end
+    end
+  end
+end

data/lib/couchbase-orm/timestamps.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "couchbase-orm/timestamps/created"
+require "couchbase-orm/timestamps/updated"
+
+module CouchbaseOrm
+
+  # This module handles the behavior for setting up document created at and
+  # updated at timestamps.
+  module Timestamps
+    extend ActiveSupport::Concern
+    include Created
+    include Updated
+  end
+end

data/lib/couchbase-orm/types/array.rb

@@ -0,0 +1,32 @@
+module CouchbaseOrm
+    module Types
+        class Array < ActiveModel::Type::Value
+            attr_reader :type_class
+            attr_reader :model_class
+
+            def initialize(type: nil)
+                if type.is_a?(Class) && type < CouchbaseOrm::NestedDocument
+                    @model_class = type
+                    @type_class = CouchbaseOrm::Types::Nested.new(type: @model_class)
+                else
+                    @type_class = ActiveModel::Type.registry.lookup(type)
+                end
+                super()
+            end
+
+            def cast(values)
+              return [] if values.nil?
+
+              raise ArgumentError, "#{values.inspect} must be an array" unless values.is_a?(::Array)
+              
+              values.map(&@type_class.method(:cast))
+            end
+        
+            def serialize(values)
+                return [] if values.nil?
+
+                values.map(&@type_class.method(:serialize))
+            end
+        end
+    end
+end

data/lib/couchbase-orm/types/date.rb

@@ -0,0 +1,9 @@
+module CouchbaseOrm
+    module Types
+        class Date < ActiveModel::Type::Date
+            def serialize(value)
+                value&.iso8601
+            end
+        end
+    end
+end

data/lib/couchbase-orm/types/date_time.rb

@@ -0,0 +1,14 @@
+module CouchbaseOrm
+    module Types
+        class DateTime < ActiveModel::Type::DateTime
+            def cast(value)
+              value = Time.at(value) if value.is_a?(Float) || value.is_a?(Integer)
+              super(value)&.utc
+            end
+
+            def serialize(value)
+                value&.iso8601(@precision)
+            end
+        end
+    end
+end

data/lib/couchbase-orm/types/encrypted.rb

@@ -0,0 +1,17 @@
+module CouchbaseOrm
+    module Types
+        class Encrypted < ActiveModel::Type::Value  
+            attr_reader :alg
+
+            def initialize(alg: "CB_MOBILE_CUSTOM")
+                @alg = alg
+                super()
+            end
+
+            def serialize(value)
+                return nil if value.nil?
+                value
+            end
+        end
+    end
+end

data/lib/couchbase-orm/types/nested.rb

@@ -0,0 +1,43 @@
+class NestedValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+        if value.is_a?(Array)
+            record.errors.add attribute, (options[:message] || "is invalid") unless value.map(&:valid?).all?
+        else
+            record.errors.add attribute, (options[:message] || "is invalid") unless
+        value.nil? || value.valid?
+        end
+
+    end
+end
+
+module CouchbaseOrm
+    module Types
+        class Nested < ActiveModel::Type::Value
+            attr_reader :model_class
+
+            def initialize(type:)
+                raise ArgumentError, "type is nil" if type.nil?
+                raise ArgumentError, "type is not a class : #{type.inspect}" unless type.is_a?(Class)
+                
+                @model_class = type
+                super()
+            end
+
+            def cast(value)
+                return nil if value.nil?
+                return value if value.is_a?(@model_class)
+                return @model_class.new(value) if value.is_a?(Hash)
+
+                raise ArgumentError, "Nested: #{value.inspect} (#{value.class}) is not supported for cast"
+            end
+        
+            def serialize(value)
+                return nil if value.nil?
+                value = @model_class.new(value) if value.is_a?(Hash)
+                return value.send(:serialized_attributes) if value.is_a?(@model_class)
+
+                raise ArgumentError, "Nested: #{value.inspect} (#{value.class}) is not supported for serialization"
+            end
+        end
+    end
+end

data/lib/couchbase-orm/types/timestamp.rb

@@ -0,0 +1,18 @@
+module CouchbaseOrm
+    module Types
+        class Timestamp < ActiveModel::Type::DateTime
+            def cast(value)
+              return nil if value.nil?
+              return Time.at(value) if value.is_a?(Integer) || value.is_a?(Float)
+              return Time.at(value.to_i) if value.is_a?(String) && value =~ /^[0-9]+$/
+              return value.utc if value.is_a?(Time)
+              super(value).utc
+            end
+        
+            def serialize(value)
+                value&.to_i
+            end
+        end
+    end
+end
+

data/lib/couchbase-orm/types.rb

@@ -0,0 +1,20 @@
+require "couchbase-orm/types/date"
+require "couchbase-orm/types/date_time"
+require "couchbase-orm/types/timestamp"
+require "couchbase-orm/types/array"
+require "couchbase-orm/types/nested"
+require "couchbase-orm/types/encrypted"
+
+if ActiveModel::VERSION::MAJOR < 6
+  # In Rails 5, the type system cannot allow overriding the default types
+  ActiveModel::Type.registry.instance_variable_get(:@registrations).delete_if do |k|
+    k.matches?(:date) || k.matches?(:datetime) || k.matches?(:timestamp)
+  end
+end
+
+ActiveModel::Type.register(:date, CouchbaseOrm::Types::Date)
+ActiveModel::Type.register(:datetime, CouchbaseOrm::Types::DateTime)
+ActiveModel::Type.register(:timestamp, CouchbaseOrm::Types::Timestamp)
+ActiveModel::Type.register(:array, CouchbaseOrm::Types::Array)
+ActiveModel::Type.register(:nested, CouchbaseOrm::Types::Nested)
+ActiveModel::Type.register(:encrypted, CouchbaseOrm::Types::Encrypted)

data/lib/couchbase-orm/utilities/enum.rb

@@ -27,7 +27,19 @@ module CouchbaseOrm
             else
                 default_value = 1
             end
-            attribute name, default: default_value
+            attribute name, :integer, default: default_value
+
+            define_method "#{name}=" do |value|
+                unless value.nil?
+                    value = case value
+                    when Symbol, String
+                        self.class.const_get(name.to_s.upcase)[value.to_sym]
+                    else
+                        Integer(value)
+                    end
+                end
+                super(value)
+            end
 
             # keep the attribute's value within bounds
             before_save do |record|