couchbase-orm 1.1.0 → 2.0.0

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

@@ -1,12 +1,9 @@
 module CouchbaseOrm
     module HasMany
-        private
-
         # :foreign_key, :class_name, :through
-        def has_many(model, class_name: nil, foreign_key: nil, through: nil, through_class: nil, through_key: nil, **options)
-            class_name  = (class_name || model.to_s.singularize.camelcase).to_s
+        def has_many(model, class_name: nil, foreign_key: nil, through: nil, through_class: nil, through_key: nil, type: :view, **options)
+            class_name = (class_name || model.to_s.singularize.camelcase).to_s
             foreign_key = (foreign_key || ActiveSupport::Inflector.foreign_key(self.name)).to_sym
-
             if through || through_class
                 remote_class = class_name
                 class_name = (through_class || through.to_s.camelcase).to_s
@@ -16,58 +13,97 @@ module CouchbaseOrm
                 remote_method = :"find_by_#{foreign_key}"
             end
 
-            relset_varname = "@#{model}_rel_set"
+            instance_var = "@__assoc_#{model}"
 
             klass = begin
-                class_name.constantize
-            rescue NameError => e
-                puts "WARNING: #{class_name} referenced in #{self.name} before it was loaded"
+                        class_name.constantize
+                    rescue NameError
+                        warn "WARNING: #{class_name} referenced in #{self.name} before it was aded"
 
-                # Open the class early - load order will have to be changed to prevent this.
-                # Warning notice required as a misspelling will not raise an error
-                Object.class_eval <<-EKLASS
-                    class #{class_name} < CouchbaseOrm::Base
-                        attribute :#{foreign_key}
+                        # Open the class early - load order will have to be changed to prevent this.
+                        # Warning notice required as a misspelling will not raise an error
+                        Object.class_eval <<-EKLASS
+                            class #{class_name} < CouchbaseOrm::Base
+                                attribute :#{foreign_key}
+                            end
+                        EKLASS
+                        class_name.constantize
                     end
-                EKLASS
-                class_name.constantize
-            end
 
+            build_index(type, klass, remote_class, remote_method, through_key, foreign_key)
 
             if remote_class
-                klass.class_eval do
-                    view remote_method, map: <<-EMAP
-    function(doc) {
-        if (doc.type === "{{design_document}}" && doc.#{through_key}) {
-            emit(doc.#{foreign_key}, null);
-        }
-    }
-EMAP
-                end
-
                 define_method(model) do
-                    return self.instance_variable_get(relset_varname) if instance_variable_defined?(relset_varname)
+                    return self.instance_variable_get(instance_var) if instance_variable_defined?(instance_var)
 
                     remote_klass = remote_class.constantize
+                    raise ArgumentError, "Can't find #{remote_method} without an id" unless self.id.present?
                     enum = klass.__send__(remote_method, key: self.id) { |row|
-                        remote_klass.find(row.value[through_key])
+                        case type
+                        when :n1ql
+                            remote_klass.find(row)
+                        when :view
+                            remote_klass.find(row[through_key])
+                        else
+                            raise 'type is unknown'
+                        end
                     }
 
-                    self.instance_variable_set(relset_varname, enum)
+                    self.instance_variable_set(instance_var, enum)
                 end
             else
-                klass.class_eval do
-                    index_view foreign_key, validate: false
-                end
-
                 define_method(model) do
-                    return self.instance_variable_get(relset_varname) if instance_variable_defined?(relset_varname)
-                    self.instance_variable_set(relset_varname, klass.__send__(remote_method, self.id))
+                    return self.instance_variable_get(instance_var) if instance_variable_defined?(instance_var)
+                    self.instance_variable_set(instance_var, self.id ? klass.__send__(remote_method, self.id) : [])
                 end
             end
 
             @associations ||= []
             @associations << [model, options[:dependent]]
         end
+
+        def build_index(type, klass, remote_class, remote_method, through_key, foreign_key)
+            case type
+            when :n1ql
+                build_index_n1ql(klass, remote_class, remote_method, through_key, foreign_key)
+            when :view
+                build_index_view(klass, remote_class, remote_method, through_key, foreign_key)
+            else
+                raise 'type is unknown'
+            end
+        end
+
+        def build_index_view(klass, remote_class, remote_method, through_key, foreign_key)
+            if remote_class
+                klass.class_eval do
+                    view remote_method, map: <<-EMAP
+                        function(doc) {
+                            if (doc.type === "{{design_document}}" && doc.#{through_key}) {
+                            emit(doc.#{foreign_key}, null);
+                            }
+                        }
+                    EMAP
+                end
+            else
+                klass.class_eval do
+                    index_view foreign_key, validate: false
+                end
+            end
+        end
+
+        def build_index_n1ql(klass, remote_class, remote_method, through_key, foreign_key)
+            if remote_class
+                klass.class_eval do
+                  n1ql remote_method, emit_key: 'id', query_fn: proc { |bucket, values, options|
+                    raise ArgumentError, "values[0] must not be blank" if values[0].blank?
+                    cluster.query("SELECT raw #{through_key} FROM `#{bucket.name}` where type = \"#{design_document}\" and #{foreign_key} = #{quote(values[0])}", options)
+                  }
+                end
+            else
+                klass.class_eval do
+                    index_n1ql foreign_key, validate: false
+                end
+            end
+        end
     end
 end

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

@@ -0,0 +1,15 @@
+module CouchbaseOrm
+    module IgnoredProperties
+        def ignored_properties=(properties)
+            @ignored_properties = properties.map(&:to_s)
+        end
+
+        def ignored_properties(*args)
+            if args.any?
+                CouchbaseOrm.logger.warn('Passing aruments to `.ignored_properties` is deprecated. PLease use `.ignored_properties=` instead.')
+                return send :ignored_properties=, args
+            end
+            @ignored_properties ||= []
+        end
+    end
+end

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

@@ -31,7 +31,7 @@ module CouchbaseOrm
 
             # collect a list of values for each key component attribute
             define_method(bucket_key_vals_method) do
-                attrs.collect {|attr| self[attr]}
+                attrs.collect {|attr| self.class.attribute_types[attr.to_s].cast(self[attr])}
             end
 
 
@@ -40,6 +40,7 @@ module CouchbaseOrm
             #----------------
             # simple wrapper around the processor proc if supplied
             define_singleton_method(processor_method) do |*values|
+                values = attrs.zip(values).map { |attr,value| attribute_types[attr.to_s].serialize(attribute_types[attr.to_s].cast(value)) }
                 if processor
                     processor.call(values.length == 1 ? values.first : values)
                 else
@@ -50,13 +51,16 @@ module CouchbaseOrm
             # use the bucket key as an index - lookup records by attr values
             define_singleton_method(find_by_method) do |*values|
                 key = self.send(class_bucket_key_method, *values)
-                id = self.bucket.get(key, quiet: true)
+                CouchbaseOrm.logger.debug { "#{find_by_method}: #{class_bucket_key_method} with values #{values.inspect} give key: #{key}" }
+                id = self.collection.get(key)&.content
                 if id
                     mod = self.find_by_id(id)
                     return mod if mod
 
                     # Clean up record if the id doesn't exist
-                    self.bucket.delete(key, quiet: true)
+                    self.collection.remove(key)
+                else
+                    CouchbaseOrm.logger.debug("#{find_by_method}: #{key} not found")
                 end
 
                 nil
@@ -70,7 +74,7 @@ module CouchbaseOrm
             if presence
                 attrs.each do |attr|
                     validates attr, presence: true
-                    define_attribute_methods attr
+                    attribute attr
                 end
             end
 
@@ -98,18 +102,29 @@ module CouchbaseOrm
             # new one. the id of the current record is used as the key's value.
             after_save do |record|
                 original_key = instance_variable_get(original_bucket_key_var)
-                record.class.bucket.delete(original_key, quiet: true) if original_key
 
-                unless presence == false && attrs.length == 1 && record[attrs[0]].nil?
-                    record.class.bucket.set(record.send(bucket_key_method), record.id, plain: true)
+                if original_key
+                    begin
+                        check_ref_id = record.class.collection.get(original_key)
+                        if check_ref_id && check_ref_id.content == record.id
+                            CouchbaseOrm.logger.debug { "Removing old key #{original_key}" }
+                            record.class.collection.remove(original_key, cas: check_ref_id.cas)
+                        end
+                    end
                 end
+
+                record.class.collection.upsert(record.send(bucket_key_method), record.id)
+
                 instance_variable_set(original_bucket_key_var, nil)
             end
 
             # cleanup by removing the bucket key before the record is deleted
             # TODO: handle unpersisted, modified component values
             before_destroy do |record|
-                record.class.bucket.delete(record.send(bucket_key_method), quiet: true)
+                check_ref_id = record.class.collection.get(record.send(bucket_key_method))
+                if check_ref_id && check_ref_id.content == record.id
+                    record.class.collection.remove(record.send(bucket_key_method), cas: check_ref_id.cas)
+                end
                 true
             end
 

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

@@ -0,0 +1,16 @@
+module CouchbaseOrm
+    module PropertiesAlwaysExistsInDocument
+
+        DEFAULT_VALUE = false
+        def properties_always_exists_in_document=(value)
+            unless [true, false].include? value
+                raise ArgumentError.new("properties_always_exists_in_document must be a boolean")
+            end
+            @properties_always_exists_in_document = value
+        end
+
+        def properties_always_exists_in_document
+            @properties_always_exists_in_document ||= DEFAULT_VALUE
+        end
+    end
+end

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

@@ -0,0 +1,148 @@
+module CouchbaseOrm
+    module QueryHelper
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+            def build_match(key, value)
+                use_is_null = self.properties_always_exists_in_document
+                key = "meta().id" if key.to_s == "id"
+                case
+                when value.nil? && use_is_null
+                    "#{key} IS NULL"
+                when value.nil? && !use_is_null
+                    "#{key} IS NOT VALUED"
+                when value.is_a?(Hash) && attribute_types[key.to_s].is_a?(CouchbaseOrm::Types::Array)
+                    "any #{key.to_s.singularize} in #{key} satisfies (#{build_match_hash("#{key.to_s.singularize}", value)}) end"
+                when value.is_a?(Hash) && !attribute_types[key.to_s].is_a?(CouchbaseOrm::Types::Array)
+                    build_match_hash(key, value)
+                when value.is_a?(Array) && value.include?(nil)
+                    "(#{build_match(key, nil)} OR #{build_match(key, value.compact)})"
+                when value.is_a?(Array)
+                    "#{key} IN #{quote(value)}"
+                when value.is_a?(Range)
+                    build_match_range(key, value)
+                else
+                    "#{key} = #{quote(value)}"
+                end
+            end
+
+            def build_match_hash(key, value)
+                matches = []
+                value.each do |k, v|
+                    case k
+                    when :_gt
+                        matches << "#{key} > #{quote(v)}"
+                    when :_gte
+                        matches << "#{key} >= #{quote(v)}"
+                    when :_lt
+                        matches << "#{key} < #{quote(v)}"
+                    when :_lte
+                        matches << "#{key} <= #{quote(v)}"
+                    when :_ne
+                        matches << "#{key} != #{quote(v)}"
+                    
+                    # TODO v2
+                    # when :_in
+                    #     matches << "#{key} IN #{quote(v)}"
+                    # when :_nin
+                    #     matches << "#{key} NOT IN #{quote(v)}"
+                    # when :_like
+                    #     matches << "#{key} LIKE #{quote(v)}"
+                    # when :_nlike
+                    #     matches << "#{key} NOT LIKE #{quote(v)}"
+                    # when :_between
+                    #     matches << "#{key} BETWEEN #{quote(v[0])} AND #{quote(v[1])}"
+                    # when :_nbetween
+                    #     matches << "#{key} NOT BETWEEN #{quote(v[0])} AND #{quote(v[1])}"
+                    # when :_exists
+                    #     matches << "#{key} IS #{v ? "" : "NOT "}VALUED"
+                    # when :_regex
+                    #     matches << "#{key} REGEXP #{quote(v)}"
+                    # when :_nregex
+                    #     matches << "#{key} NOT REGEXP #{quote(v)}"
+                    # when :_match
+                    #     matches << "#{key} MATCH #{quote(v)}"
+                    # when :_nmatch
+                    #     matches << "#{key} NOT MATCH #{quote(v)}"
+                    
+                    # TODO v3
+                    # when :_any
+                    #     matches << "#{key} ANY #{quote(v)}"
+                    # when :_nany
+                    #     matches << "#{key} NOT ANY #{quote(v)}"
+                    # when :_all
+                    #     matches << "#{key} ALL #{quote(v)}"
+                    # when :_nall
+                    #     matches << "#{key} NOT ALL #{quote(v)}"
+                    # when :_within
+                    #     matches << "#{key} WITHIN #{quote(v)}"
+                    #when :_nwithin
+                    #    matches << "#{key} NOT WITHIN #{quote(v)}"
+                    else
+                        matches << build_match("#{key}.#{k}", v)
+                    end
+                end
+                
+                matches.join(" AND ")
+            end
+
+            def build_match_range(key, value)
+                matches = []
+                matches << "#{key} >= #{quote(value.begin)}"
+                if value.exclude_end?
+                    matches << "#{key} < #{quote(value.end)}"
+                else
+                    matches << "#{key} <= #{quote(value.end)}"
+                end
+                matches.join(" AND ")
+            end
+
+
+            def build_not_match(key, value)
+                use_is_null = self.properties_always_exists_in_document
+                key = "meta().id" if key.to_s == "id"
+                case
+                when value.nil? && use_is_null
+                    "#{key} IS NOT NULL"
+                when value.nil? && !use_is_null
+                    "#{key} IS VALUED"
+                when value.is_a?(Array) && value.include?(nil)
+                    "(#{build_not_match(key, nil)} AND #{build_not_match(key, value.compact)})"
+                when value.is_a?(Array)
+                    "#{key} NOT IN #{quote(value)}"
+                else
+                    "#{key} != #{quote(value)}"
+                end
+            end
+
+            def serialize_value(key, value_before_type_cast)
+                value = 
+                    if value_before_type_cast.is_a?(Array)
+                        value_before_type_cast.map do |v|
+                            attribute_types[key.to_s].serialize(attribute_types[key.to_s].cast(v))
+                        end
+                    else
+                        attribute_types[key.to_s].serialize(attribute_types[key.to_s].cast(value_before_type_cast))
+                    end
+                CouchbaseOrm.logger.debug { "convert_values: #{key} => #{value_before_type_cast.inspect} => #{value.inspect} #{value.class} #{attribute_types[key.to_s]}" }
+                value
+            end
+
+            def quote(value)
+                if [String, Date].any? { |clazz| value.is_a?(clazz) }
+                    "'#{N1ql.sanitize(value)}'"
+                elsif [DateTime, Time].any? { |clazz| value.is_a?(clazz) }
+                    formatedDate = value&.iso8601(@precision)
+                    "'#{N1ql.sanitize(formatedDate)}'"
+                elsif value.is_a? Array
+                    "[#{value.map{|v|quote(v)}.join(', ')}]"
+                elsif value.nil?
+                    nil
+                else
+                    N1ql.sanitize(value).to_s
+                end
+            end
+        end
+    end
+end

data/lib/couchbase-orm/utils.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CouchbaseOrm
+  # Utility functions for CouchbaseOrm.
+  #
+  # @api private
+  module Utils
+    extend self
+
+    # A unique placeholder value that will never accidentally collide with
+    # valid values. This is useful as a default keyword argument value when
+    # you want the argument to be optional, but you also want to be able to
+    # recognize that the caller did not provide a value for it.
+    PLACEHOLDER = Object.new.freeze
+
+    # Asks if the given value is a placeholder or not.
+    #
+    # @param [ Object ] value the value to compare
+    #
+    # @return [ true | false ] if the value is a placeholder or not.
+    def placeholder?(value)
+      value == PLACEHOLDER
+    end
+  end
+end

data/lib/couchbase-orm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true, encoding: ASCII-8BIT
 
 module CouchbaseOrm
-    VERSION = '1.1.0'
+  VERSION = '2.0.0'
 end

data/lib/couchbase-orm/views.rb

@@ -19,16 +19,18 @@ module CouchbaseOrm
             #    view :by_rating, emit_key: :rating
             #  end
             #
-            #  Post.by_rating.stream do |response|
+            #  Post.by_rating do |response|
             #    # ...
             #  end
             def view(name, map: nil, emit_key: nil, reduce: nil, **options)
+                raise ArgumentError, "#{self} already respond_to? #{name}" if self.respond_to?(name)
+                
                 if emit_key.class == Array
                     emit_key.each do |key|
-                        raise "unknown emit_key attribute for view :#{name}, emit_key: :#{key}" if key && @attributes[key].nil?
+                        raise "unknown emit_key attribute for view :#{name}, emit_key: :#{key}" if key && !attribute_names.include?(key.to_s)
                     end
                 else
-                    raise "unknown emit_key attribute for view :#{name}, emit_key: :#{emit_key}" if emit_key && @attributes[emit_key].nil?
+                    raise "unknown emit_key attribute for view :#{name}, emit_key: :#{emit_key}" if emit_key && !attribute_names.include?(emit_key.to_s)
                 end
 
                 options = ViewDefaults.merge(options)
@@ -48,27 +50,13 @@ function(doc) {
 EMAP
                     else
                         emit_key = emit_key || :created_at
-
-                        if emit_key != :created_at && self.attributes[emit_key][:type].to_s == 'Array'
-                            method_opts[:map] = <<-EMAP
-function(doc) {
-    var i;
-    if (doc.type === "{{design_document}}") {
-        for (i = 0; i < doc.#{emit_key}.length; i += 1) {
-            emit(doc.#{emit_key}[i], null);
-        }
-    }
-}
-EMAP
-                        else
-                            method_opts[:map] = <<-EMAP
+                        method_opts[:map] = <<-EMAP
 function(doc) {
     if (doc.type === "{{design_document}}") {
         emit(doc.#{emit_key}, null);
     }
 }
 EMAP
-                        end
                     end
                 end
 
@@ -78,17 +66,14 @@ EMAP
                 @views[name] = method_opts
 
                 singleton_class.__send__(:define_method, name) do |**opts, &result_modifier|
-                    opts = options.merge(opts)
-
+                    opts = options.merge(opts).reverse_merge(scan_consistency: CouchbaseOrm::N1ql.config[:scan_consistency])
+                    CouchbaseOrm.logger.debug("View [#{@design_document}, #{name.inspect}] options: #{opts.inspect}")
                     if result_modifier
-                        opts[:include_docs] = true
-                        bucket.view(@design_document, name, **opts, &result_modifier)
+                        include_docs(bucket.view_query(@design_document, name.to_s, Couchbase::Options::View.new(**opts.except(:include_docs)))).map(&result_modifier)
                     elsif opts[:include_docs]
-                        bucket.view(@design_document, name, **opts) { |row|
-                            self.new(row)
-                        }
+                        include_docs(bucket.view_query(@design_document, name.to_s, Couchbase::Options::View.new(**opts.except(:include_docs))))
                     else
-                        bucket.view(@design_document, name, **opts)
+                        bucket.view_query(@design_document, name.to_s, Couchbase::Options::View.new(**opts.except(:include_docs)))
                     end
                 end
             end
@@ -116,26 +101,28 @@ EMAP
                 update_required = false
 
                 # Grab the existing view details
-                ddoc = bucket.design_docs[@design_document]
-                existing = ddoc.view_config if ddoc
-
+                begin
+                    ddoc = bucket.view_indexes.get_design_document(@design_document, :production)
+                rescue Couchbase::Error::DesignDocumentNotFound
+                end
+                existing = ddoc.views if ddoc
                 views_actual = {}
                 # Fill in the design documents
                 @views.each do |name, document|
-                    doc = document.dup
-                    views_actual[name] = doc
-                    doc[:map] = doc[:map].gsub('{{design_document}}', @design_document) if doc[:map]
-                    doc[:reduce] = doc[:reduce].gsub('{{design_document}}', @design_document) if doc[:reduce]
+                    views_actual[name.to_s] = Couchbase::Management::View.new(
+                        document[:map]&.gsub('{{design_document}}', @design_document),
+                        document[:reduce]&.gsub('{{design_document}}', @design_document)
+                    )
                 end
 
                 # Check there are no changes we need to apply
                 views_actual.each do |name, desired|
                     check = existing[name]
                     if check
-                        cmap = (check[:map] || '').gsub(/\s+/, '')
-                        creduce = (check[:reduce] || '').gsub(/\s+/, '')
-                        dmap = (desired[:map] || '').gsub(/\s+/, '')
-                        dreduce = (desired[:reduce] || '').gsub(/\s+/, '')
+                        cmap = (check.map || '').gsub(/\s+/, '')
+                        creduce = (check.reduce || '').gsub(/\s+/, '')
+                        dmap = (desired.map || '').gsub(/\s+/, '')
+                        dreduce = (desired.reduce || '').gsub(/\s+/, '')
 
                         unless cmap == dmap && creduce == dreduce
                             update_required = true
@@ -149,16 +136,26 @@ EMAP
 
                 # Updated the design document
                 if update_required
-                    bucket.save_design_doc({
-                        views: views_actual
-                    }, @design_document)
+                    document = Couchbase::Management::DesignDocument.new
+                    document.views = views_actual
+                    document.name = @design_document
+                    bucket.view_indexes.upsert_design_document(document, :production)
 
-                    puts "Couchbase views updated for #{self.name}, design doc: #{@design_document}"
                     true
                 else
                     false
                 end
             end
+
+            def include_docs(view_result)
+                if view_result.rows.length > 1
+                    self.find(view_result.rows.map(&:id))
+                elsif view_result.rows.length == 1
+                    [self.find(view_result.rows.first.id)]
+                else
+                    []
+                end
+            end
         end
     end
 end

data/lib/couchbase-orm.rb

@@ -1,23 +1,58 @@
 # frozen_string_literal: true, encoding: ASCII-8BIT
+require "logger"
+require "active_support/lazy_load_hooks"
+require "couchbase-orm/utils"
 
-require 'libcouchbase'
+ActiveSupport.on_load(:i18n) do
+    I18n.load_path << File.expand_path("couchbase-orm/locale/en.yml", __dir__)
+end
 
 module CouchbaseOrm
+    autoload :Encrypt,      'couchbase-orm/encrypt'
     autoload :Error,       'couchbase-orm/error'
     autoload :Connection,  'couchbase-orm/connection'
     autoload :IdGenerator, 'couchbase-orm/id_generator'
     autoload :Base,        'couchbase-orm/base'
+    autoload :Document,        'couchbase-orm/base'
+    autoload :NestedDocument,   'couchbase-orm/base'
+    autoload :HasMany,     'couchbase-orm/utilities/has_many'
+
+    def self.logger
+        @@logger ||= defined?(Rails) ? Rails.logger : Logger.new(STDOUT).tap { |l| l.level = Logger::INFO unless ENV["COUCHBASE_ORM_DEBUG"] }
+    end
+
+    def self.logger=(logger)
+        @@logger = logger
+    end
 
     def self.try_load(id)
         result = nil
-        result = id.respond_to?(:cas) ? id : CouchbaseOrm::Base.bucket.get(id, quiet: true, extended: true)
-
-        if result && result.value.is_a?(Hash) && result.value[:type]
-            ddoc = result.value[:type]
-            ::CouchbaseOrm::Base.descendants.each do |model|
-                if model.design_document == ddoc
-                    return model.new(result)
-                end
+        was_array = id.is_a?(Array)
+        if was_array && id.length == 1
+            query_id = id.first
+        else
+            query_id = id
+        end
+
+        result = query_id.is_a?(Array) ? CouchbaseOrm::Base.bucket.default_collection.get_multi(query_id) : CouchbaseOrm::Base.bucket.default_collection.get(query_id)
+
+        result = Array.wrap(result) if was_array
+
+        if result&.is_a?(Array)
+            return result.zip(id).map { |r, id| try_load_create_model(r, id) }.compact
+        end
+
+        return try_load_create_model(result, id)
+    end
+
+    private
+
+    def self.try_load_create_model(result, id)
+        ddoc = result&.content["type"]
+        return nil unless ddoc
+        ::CouchbaseOrm::Base.descendants.each do |model|
+            if model.design_document == ddoc
+                return model.new(result, id: id)
             end
         end
         nil