couchbase-orm 1.1.1 → 2.0.2

data/lib/couchbase-orm/json_schema/loader.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'singleton'
+
+module CouchbaseOrm
+  module JsonSchema
+    class Loader
+      include Singleton
+      class Error < StandardError; end
+
+      JSON_SCHEMAS_PATH = 'db/cborm_schemas'
+
+      attr_reader :schemas
+
+      def initialize(json_schemas_path = JSON_SCHEMAS_PATH)
+        @schemas_directory = json_schemas_path
+        @schemas = {}
+        unless File.directory?(schemas_directory)
+          CouchbaseOrm.logger.info { "Directory not found #{schemas_directory}" }
+        end
+      end
+
+      def extract_type(entity = {})
+        entity[:type]
+      end
+
+      def get_json_schema!(entity, schema_path: nil)
+        document_type = extract_type!(entity)
+
+        return schemas[document_type] if schemas.key?(document_type)
+
+        schema_path ||= File.join(schemas_directory, "#{document_type}.json")
+
+        raise(Error, "Schema not found for #{document_type} in #{schema_path}") unless File.exist?(schema_path)
+
+        schemas[document_type] = File.read schema_path
+      end
+
+      private
+
+      attr_reader :schemas_directory
+
+      def extract_type!(entity = {})
+        extract_type(entity) || raise(Error, "No type found in #{entity}")
+      end
+    end
+  end
+end

data/lib/couchbase-orm/json_schema/validation.rb

@@ -0,0 +1,18 @@
+module CouchbaseOrm
+  module JsonSchema
+    module Validation
+
+      def validate_json_schema(mode: :strict, schema_path: nil)
+        @json_validation_config = {
+          enabled: true,
+          mode: mode,
+          schema_path: schema_path,
+        }.freeze
+      end
+
+      def json_validation_config
+        @json_validation_config ||= {}
+      end
+    end
+  end
+end

data/lib/couchbase-orm/json_schema/validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+require 'json-schema'
+
+module CouchbaseOrm
+  module JsonSchema
+    class Validator
+
+      def initialize(json_validation_config)
+        @json_validation_config = json_validation_config
+      end
+
+      def validate_entity(entity, json)
+        case json_validation_config[:mode]
+        when :strict
+          strict_validation(entity, json)
+        when :logger
+          logger_validation(entity, json)
+        else
+          raise "Unknown validation mode #{json_validation_config[:mode]}"
+        end
+      end
+
+      private
+
+      attr_reader :json_validation_config
+
+      def strict_validation(entity, json)
+        error_results = common_validate(entity, json)
+        raise JsonValidationError.new(Loader.instance.extract_type(entity), error_results) unless error_results.empty?
+      end
+
+      def logger_validation(entity, json)
+        error_results = common_validate(entity, json)
+        CouchbaseOrm.logger.error { "[COUCHBASEORM]: Invalid document #{Loader.instance.extract_type(entity)} with errors : #{error_results}" } unless error_results.empty?
+      end
+
+      def common_validate(entity, json)
+        schema = Loader.instance.get_json_schema!(entity, schema_path: json_validation_config[:schema_path])
+        JSON::Validator.fully_validate(schema, json)
+      end
+    end
+  end
+end

data/lib/couchbase-orm/json_schema.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'couchbase-orm/json_schema/loader'
+require 'couchbase-orm/json_schema/validator'
+require 'couchbase-orm/json_schema/json_validation_error'
+module CouchbaseOrm
+  module JsonSchema
+  end
+end

data/lib/couchbase-orm/json_transcoder.rb

@@ -0,0 +1,27 @@
+require "json"
+require 'couchbase/json_transcoder'
+require 'couchbase-orm/json_schema'
+
+module CouchbaseOrm
+  class JsonTranscoder < Couchbase::JsonTranscoder
+
+    attr_reader :ignored_properties, :json_validation_config
+
+    def initialize(ignored_properties: [], json_validation_config: {}, **options, &block)
+      @ignored_properties = ignored_properties
+      @json_validation_config = json_validation_config
+      super(**options, &block)
+    end
+
+    def decode(blob, _flags)
+      original = super
+      original&.except(*ignored_properties)
+    end
+
+    def encode(document)
+      original = super
+      CouchbaseOrm::JsonSchema::Validator.new(json_validation_config).validate_entity(document, original[0]) if document.present? && !original.empty? && json_validation_config[:enabled]
+      original
+    end
+  end
+end

data/lib/couchbase-orm/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  couchbase:
+    errors:
+      messages:
+        record_invalid: "Validation failed: %{errors}"

data/lib/couchbase-orm/n1ql.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/try'
+
+module CouchbaseOrm
+    module N1ql
+        extend ActiveSupport::Concern
+        NO_VALUE = :no_value_specified
+        DEFAULT_SCAN_CONSISTENCY = :request_plus
+        # sanitize for injection query
+        def self.sanitize(value)
+            if value.is_a?(String)
+                value.gsub("'", "''").gsub("\\"){"\\\\"}.gsub('"', '\"')
+            elsif value.is_a?(Array)
+                value.map{ |v| sanitize(v) }
+            else
+                value
+            end
+        end
+
+        def self.config(new_config = nil)
+            Thread.current['__couchbaseorm_n1ql_config__'] = new_config if new_config
+            Thread.current['__couchbaseorm_n1ql_config__'] || {
+                scan_consistency: DEFAULT_SCAN_CONSISTENCY
+            }
+        end
+
+        module ClassMethods
+            # Defines a query N1QL for the model
+            #
+            # @param [Symbol, String, Array] names names of the views
+            # @param [Hash] options options passed to the {Couchbase::N1QL}
+            #
+            # @example Define some N1QL queries for a model
+            #  class Post < CouchbaseOrm::Base
+            #    n1ql :by_rating, emit_key: :rating
+            #  end
+            #
+            #  Post.by_rating do |response|
+            #    # ...
+            #  end
+            # TODO: add range keys [:startkey, :endkey]
+            def n1ql(name, query_fn: nil, emit_key: [], custom_order: nil, **options)
+                raise ArgumentError, "#{self} already respond_to? #{name}" if self.respond_to?(name)
+
+                emit_key = Array.wrap(emit_key)
+                emit_key.each do |key|
+                    raise "unknown emit_key attribute for n1ql :#{name}, emit_key: :#{key}" if key && !attribute_names.include?(key.to_s)
+                end
+                options = N1QL_DEFAULTS.merge(options)
+                method_opts = {}
+                method_opts[:emit_key] = emit_key
+
+                @indexes ||= {}
+                @indexes[name] = method_opts
+
+                singleton_class.__send__(:define_method, name) do |key: NO_VALUE, **opts, &result_modifier|
+                    opts = options.merge(opts).reverse_merge(scan_consistency: CouchbaseOrm::N1ql.config[:scan_consistency])
+                    values = key == NO_VALUE ? NO_VALUE : convert_values(method_opts[:emit_key], key)
+                    current_query = run_query(method_opts[:emit_key], values, query_fn, custom_order: custom_order, **opts.except(:include_docs, :key))
+                    if result_modifier
+                        opts[:include_docs] = true
+                        current_query.results &result_modifier
+                    elsif opts[:include_docs]
+                        current_query.results { |res| find(res) }
+                    else
+                        current_query.results
+                    end
+                end
+            end
+            N1QL_DEFAULTS = { include_docs: true }
+
+            # add a n1ql query and lookup method to the model for finding all records
+            # using a value in the supplied attr.
+            def index_n1ql(attr, validate: true, find_method: nil, n1ql_method: nil)
+                n1ql_method ||= "by_#{attr}"
+                find_method ||= "find_#{n1ql_method}"
+
+                validates(attr, presence: true) if validate
+                n1ql n1ql_method, emit_key: attr
+
+                define_singleton_method find_method do |value|
+                    send n1ql_method, key: [value]
+                end
+            end
+
+            private
+
+            def convert_values(keys, values)
+                return values if keys.empty? && Array.wrap(values).any?
+                keys.zip(Array.wrap(values)).map do |key, value_before_type_cast|
+                    serialize_value(key, value_before_type_cast)
+                end
+            end
+
+            def build_where(keys, values)
+                where = values == NO_VALUE ? '' : keys.zip(Array.wrap(values))
+                            .reject { |key, value| key.nil? && value.nil? }
+                            .map { |key, value| build_match(key, value) }
+                            .join(" AND ")
+                "type=\"#{design_document}\" #{"AND " + where unless where.blank?}"
+            end
+
+            # order-by-clause ::= ORDER BY ordering-term [ ',' ordering-term ]*
+            # ordering-term ::= expr [ ASC | DESC ] [ NULLS ( FIRST | LAST ) ]
+            # see https://docs.couchbase.com/server/5.0/n1ql/n1ql-language-reference/orderby.html
+            def build_order(keys, descending)
+                "#{keys.dup.push("meta().id").map { |k| "#{k} #{descending ? "desc" : "asc" }" }.join(",")}"
+            end
+
+            def build_limit(limit)
+                limit ? "limit #{limit}" : ""
+            end
+
+            def run_query(keys, values, query_fn, custom_order: nil, descending: false, limit: nil, **options)
+                if query_fn
+                    N1qlProxy.new(query_fn.call(bucket, values, Couchbase::Options::Query.new(**options)))
+                else
+                    bucket_name = bucket.name
+                    where = build_where(keys, values)
+                    order = custom_order || build_order(keys, descending)
+                    limit = build_limit(limit)
+                    n1ql_query = "select raw meta().id from `#{bucket_name}` where #{where} order by #{order} #{limit}"
+                    result = cluster.query(n1ql_query, Couchbase::Options::Query.new(**options))
+                    CouchbaseOrm.logger.debug  "N1QL query: #{n1ql_query} return #{result.rows.to_a.length} rows with scan_consistency : #{options[:scan_consistency]}"
+                    N1qlProxy.new(result)
+                end
+            end
+        end
+    end
+end

data/lib/couchbase-orm/persistence.rb

@@ -2,11 +2,18 @@
 
 require 'active_model'
 require 'active_support/hash_with_indifferent_access'
+require 'couchbase-orm/json_transcoder'
+require 'couchbase-orm/encrypt'
 
 module CouchbaseOrm
     module Persistence
         extend ActiveSupport::Concern
 
+        include CouchbaseOrm::Encrypt
+
+        included do
+            attribute :id, :string
+        end
 
         module ClassMethods
             def create(attributes = nil, &block)
@@ -15,6 +22,7 @@ module CouchbaseOrm
                 else
                     instance = new(attributes, &block)
                     instance.save
+                    instance.reset_object!
                     instance
                 end
             end
@@ -25,6 +33,7 @@ module CouchbaseOrm
                 else
                     instance = new(attributes, &block)
                     instance.save!
+                    instance.reset_object!
                     instance
                 end
             end
@@ -54,20 +63,19 @@ module CouchbaseOrm
         # Returns true if this object hasn't been saved yet -- that is, a record
         # for the object doesn't exist in the database yet; otherwise, returns false.
         def new_record?
-            @__metadata__.cas.nil? && @__metadata__.key.nil?
+            @__metadata__.cas.nil?
         end
         alias_method :new?, :new_record?
 
         # Returns true if this object has been destroyed, otherwise returns false.
         def destroyed?
-            !!(@__metadata__.cas && @__metadata__.key.nil?)
+            @destroyed ||= false
         end
 
         # Returns true if the record is persisted, i.e. it's not a new record and it was
         # not destroyed, otherwise returns false.
         def persisted?
-            # Changed? is provided by ActiveModel::Dirty
-            !!@__metadata__.key
+            !new_record? && !destroyed?
         end
         alias_method :exists?, :persisted?
 
@@ -99,16 +107,18 @@ module CouchbaseOrm
         # The record is simply removed, no callbacks are executed.
         def delete(with_cas: false, **options)
             options[:cas] = @__metadata__.cas if with_cas
-            self.class.bucket.delete(@__metadata__.key, options)
-
-            @__metadata__.key = nil
-            @id = nil
+            CouchbaseOrm.logger.debug "Data - Delete #{self.id}"
+            self.class.collection.remove(self.id, **options)
 
+            self.id = nil
             clear_changes_information
+            @destroyed = true
             self.freeze
             self
         end
 
+        alias :remove :delete
+
         # Deletes the record in the database and freezes this instance to reflect
         # that no changes should be made (since they can't be persisted).
         #
@@ -121,12 +131,13 @@ module CouchbaseOrm
                 destroy_associations!
 
                 options[:cas] = @__metadata__.cas if with_cas
-                self.class.bucket.delete(@__metadata__.key, options)
+                CouchbaseOrm.logger.debug "Data - Destroy #{id}"
+                self.class.collection.remove(id, **options)
 
-                @__metadata__.key = nil
-                @id = nil
+                self.id = nil
 
                 clear_changes_information
+                @destroyed = true
                 freeze
             end
         end
@@ -141,7 +152,12 @@ module CouchbaseOrm
             public_send(:"#{name}=", value)
             changed? ? save(validate: false) : true
         end
-        
+
+        def assign_attributes(hash)
+            hash = hash.with_indifferent_access if hash.is_a?(Hash)
+            super(hash.except("type"))
+        end
+
         # Updates the attributes of the model from the passed-in hash and saves the
         # record. If the object is invalid, the saving will fail and false will be returned.
         def update(hash)
@@ -158,10 +174,12 @@ module CouchbaseOrm
         end
         alias_method :update_attributes!, :update!
 
-        # Updates the record without validating or running callbacks
+        # Updates the record without validating or running callbacks.
+        # Updates only the attributes that are passed in as parameters
+        # except if there is more than 16 attributes, in which case
+        # the whole record is saved.
         def update_columns(with_cas: false, **hash)
-            _id = @__metadata__.key
-            raise "unable to update columns, model not persisted" unless _id
+            raise "unable to update columns, model not persisted" unless id
 
             assign_attributes(hash)
 
@@ -170,20 +188,17 @@ module CouchbaseOrm
 
             # There is a limit of 16 subdoc operations per request
             resp = if hash.length <= 16
-                subdoc = self.class.bucket.subdoc(_id)
-                hash.each do |key, value|
-                    subdoc.dict_upsert(key, value)
-                end
-                subdoc.execute!(options)
+                self.class.collection.mutate_in(
+                    id,
+                    hash.map { |k, v| Couchbase::MutateInSpec.replace(k.to_s, v) }
+                )
             else
                 # Fallback to writing the whole document
-                @__attributes__[:type] = self.class.design_document
-                @__attributes__.delete(:id)
-                self.class.bucket.replace(_id, @__attributes__, **options)
+                CouchbaseOrm.logger.debug { "Data - Replace #{id} #{attributes.to_s.truncate(200)}" }
+                self.class.collection.replace(id, attributes.except("id").merge(type: self.class.design_document), **options)
             end
 
             # Ensure the model is up to date
-            @__metadata__.key = resp.key
             @__metadata__.cas = resp.cas
 
             changes_applied
@@ -194,47 +209,43 @@ module CouchbaseOrm
         #
         # This method finds record by its key and modifies the receiver in-place:
         def reload
-            key = @__metadata__.key
-            raise "unable to reload, model not persisted" unless key
+            raise "unable to reload, model not persisted" unless id
 
-            resp = self.class.bucket.get(key, quiet: false, extended: true)
-            @__attributes__ = ::ActiveSupport::HashWithIndifferentAccess.new(resp.value)
-            @__metadata__.key = resp.key
+            CouchbaseOrm.logger.debug "Data - Get #{id}"
+            resp = self.class.collection.get!(id)
+            assign_attributes(decode_encrypted_attributes(resp.content.except("id", *self.class.ignored_properties ))) # API return a nil id
             @__metadata__.cas = resp.cas
 
             reset_associations
             clear_changes_information
+            reset_object!
             self
         end
 
         # Updates the TTL of the document
         def touch(**options)
-            res = self.class.bucket.touch(@__metadata__.key, async: false, **options)
+            CouchbaseOrm.logger.debug "Data - Touch #{id}"
+            _res = self.class.collection.touch(id, async: false, **options)
             @__metadata__.cas = resp.cas
             self
         end
 
 
-        protected
-
 
-        def _update_record(with_cas: false, **options)
+        def _update_record(*_args, with_cas: false, **options)
             return false unless perform_validations(:update, options)
-            return true unless changed?
+            return true unless changed? || self.class.attribute_types.any? { |_, type| type.is_a?(CouchbaseOrm::Types::Nested) || type.is_a?(CouchbaseOrm::Types::Array)  }
 
             run_callbacks :update do
                 run_callbacks :save do
-                    # Ensure the type is set
-                    @__attributes__[:type] = self.class.design_document
-                    @__attributes__.delete(:id)
-
-                    _id = @__metadata__.key
                     options[:cas] = @__metadata__.cas if with_cas
-
-                    resp = self.class.bucket.replace(_id, @__attributes__, **options)
+                    CouchbaseOrm.logger.debug { "_update_record - replace #{id} #{serialized_attributes.to_s.truncate(200)}" }
+                    if options[:transcoder].nil?
+                        options[:transcoder] = CouchbaseOrm::JsonTranscoder.new(json_validation_config: self.class.json_validation_config)
+                    end
+                    resp = self.class.collection.replace(id, serialized_attributes.except("id").merge(type: self.class.design_document), Couchbase::Options::Replace.new(**options))
 
                     # Ensure the model is up to date
-                    @__metadata__.key = resp.key
                     @__metadata__.cas = resp.cas
 
                     changes_applied
@@ -242,21 +253,19 @@ module CouchbaseOrm
                 end
             end
         end
-
-        def _create_record(**options)
+        def _create_record(*_args, **options)
             return false unless perform_validations(:create, options)
 
             run_callbacks :create do
                 run_callbacks :save do
-                    # Ensure the type is set
-                    @__attributes__[:type] = self.class.design_document
-                    @__attributes__.delete(:id)
-
-                    _id = @id || self.class.uuid_generator.next(self)
-                    resp = self.class.bucket.add(_id, @__attributes__, **options)
+                    assign_attributes(id: self.class.uuid_generator.next(self)) unless self.id
+                    CouchbaseOrm.logger.debug { "_create_record - Upsert #{id} #{serialized_attributes.to_s.truncate(200)}" }
+                    if options[:transcoder].nil?
+                        options[:transcoder] = CouchbaseOrm::JsonTranscoder.new(json_validation_config: self.class.json_validation_config)
+                    end
+                    resp = self.class.collection.upsert(self.id, serialized_attributes.except("id").merge(type: self.class.design_document), Couchbase::Options::Upsert.new(**options))
 
                     # Ensure the model is up to date
-                    @__metadata__.key = resp.key
                     @__metadata__.cas = resp.cas
 
                     changes_applied
@@ -270,4 +279,4 @@ module CouchbaseOrm
             true
         end
     end
-end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'couchbase-orm/proxies/n1ql_proxy'
+
+module CouchbaseOrm
+    class BucketProxy
+        def initialize(proxyfied)
+            raise ArgumentError, "Must proxy a non nil object" if proxyfied.nil?
+
+            @proxyfied = proxyfied
+
+            self.class.define_method(:n1ql) do
+                N1qlProxy.new(@proxyfied.n1ql)
+            end
+
+            self.class.define_method(:view) do |design, view, **opts, &block|
+                @results = nil if @current_query != "#{design}_#{view}"
+                @current_query = "#{design}_#{view}"
+                return @results if @results
+
+                CouchbaseOrm.logger.debug "View - #{design} #{view}"
+                @results = ResultsProxy.new(@proxyfied.send(:view, design, view, **opts, &block))
+            end
+        end
+    
+        if RUBY_VERSION.to_i >= 3
+            def method_missing(name, *args, **options, &block)
+                @proxyfied.public_send(name, *args, **options, &block)
+            end
+        else
+            def method_missing(name, *args, &block)
+                @proxyfied.public_send(name, *args, &block)
+            end
+        end
+    end
+end

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

@@ -0,0 +1,52 @@
+require "couchbase"
+
+module CouchbaseOrm
+    class CollectionProxy
+
+        def get!(id, **options)
+            @proxyfied.get(id, Couchbase::Options::Get.new(**options))
+        end
+
+        def get(id, **options)
+            @proxyfied.get(id, Couchbase::Options::Get.new(**options))
+        rescue Couchbase::Error::DocumentNotFound
+            nil
+        end
+
+        def get_multi!(*ids, **options)
+            result = @proxyfied.get_multi(*ids, Couchbase::Options::GetMulti.new(**options))
+            first_result_with_error = result.find(&:error)
+            raise first_result_with_error.error if first_result_with_error
+            result
+        end
+
+        def get_multi(*ids, **options)
+            @proxyfied.get_multi(*ids, Couchbase::Options::GetMulti.new(**options))
+        end
+
+        def remove!(id, **options)
+            @proxyfied.remove(id, Couchbase::Options::Remove.new(**options))
+        end
+
+        def remove(id, **options)
+            @proxyfied.remove(id, Couchbase::Options::Remove.new(**options))
+        rescue Couchbase::Error::DocumentNotFound
+            nil
+        end
+
+        def initialize(proxyfied)
+            raise "Must proxy a non nil object" if proxyfied.nil?
+            @proxyfied = proxyfied
+        end
+        
+        if RUBY_VERSION.to_i >= 3
+            def method_missing(name, *args, **options, &block)
+                @proxyfied.public_send(name, *args, **options, &block)
+            end
+        else # :nocov:
+            def method_missing(name, *args, &block) 
+                @proxyfied.public_send(name, *args, &block)
+            end
+        end
+    end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'couchbase-orm/proxies/results_proxy'
+
+module CouchbaseOrm
+    class N1qlProxy
+        def initialize(proxyfied)
+            @proxyfied = proxyfied
+
+            self.class.define_method(:results) do |*params, &block|
+                @results = nil if @current_query != self.to_s
+                @current_query = self.to_s
+                return @results if @results
+
+                CouchbaseOrm.logger.debug { 'Query - ' + self.to_s }
+
+                results = @proxyfied.rows
+                results = results.map { |r| block.call(r) } if block
+                @results = ResultsProxy.new(results.to_a)
+            end
+
+            self.class.define_method(:to_s) do
+                @proxyfied.to_s.tr("\n", ' ')
+            end
+
+            proxyfied.public_methods.each do |method|
+                next if self.public_methods.include?(method)
+
+                self.class.define_method(method) do |*params, &block|
+                    ret = @proxyfied.send(method, *params, &block)
+                    ret.is_a?(@proxyfied.class) ? self : ret
+                end
+            end
+        end
+
+        def method_missing(m, *args, &block)
+            self.results.send(m, *args, &block)
+        end
+    end
+end