wcc-contentful 0.2.2 → 0.3.0.pre.rc

data/lib/wcc/contentful/store/cdn_adapter.rb

@@ -11,63 +11,133 @@ module WCC::Contentful::Store
       @client = client
     end
 
-    def find(key)
+    def find(key, hint: nil, **options)
+      options = { locale: '*' }.merge!(options || {})
       entry =
-        begin
-          client.entry(key, locale: '*')
-        rescue WCC::Contentful::SimpleClient::NotFoundError
-          client.asset(key, locale: '*')
+        if hint
+          client.public_send(hint.underscore, key, options)
+        else
+          begin
+            client.entry(key, options)
+          rescue WCC::Contentful::SimpleClient::NotFoundError
+            client.asset(key, options)
+          end
         end
       entry&.raw
     rescue WCC::Contentful::SimpleClient::NotFoundError
       nil
     end
 
-    def find_by(content_type:, filter: nil)
+    def find_by(content_type:, filter: nil, options: nil)
       # default implementation - can be overridden
-      q = find_all(content_type: content_type)
+      q = find_all(content_type: content_type, options: { limit: 1 }.merge!(options || {}))
       q = q.apply(filter) if filter
       q.first
     end
 
-    def find_all(content_type:)
-      Query.new(@client, content_type: content_type)
+    def find_all(content_type:, options: nil)
+      Query.new(
+        store: self,
+        client: @client,
+        relation: { content_type: content_type },
+        options: options
+      )
     end
 
     class Query < Base::Query
-      delegate :count, to: :resolve
+      delegate :count, to: :response
 
       def result
-        resolve.items
+        return response.items unless @options[:include]
+
+        response.items.map { |e| resolve_includes(e, @options[:include]) }
       end
 
-      def initialize(client, relation)
+      def initialize(store:, client:, relation:, options: nil, **extra)
         raise ArgumentError, 'Client cannot be nil' unless client.present?
         raise ArgumentError, 'content_type must be provided' unless relation[:content_type].present?
+
+        super(store)
         @client = client
         @relation = relation
+        @options = options || {}
+        @extra = extra || {}
       end
 
-      def eq(field, expected, context = nil)
-        locale = context[:locale] if context.present?
-        locale ||= 'en-US'
-        Query.new(@client,
-          @relation.merge("fields.#{field}.#{locale}" => expected))
+      def apply_operator(operator, field, expected, context = nil)
+        op = operator == :eq ? nil : operator
+        param = parameter(field, operator: op, context: context, locale: true)
+
+        self.class.new(
+          store: @store,
+          client: @client,
+          relation: @relation.merge(param => expected),
+          options: @options,
+          **@extra
+        )
+      end
+
+      def nested_conditions(field, conditions, context)
+        base_param = parameter(field)
+
+        conditions.reduce(self) do |query, (ref, value)|
+          query.apply({ "#{base_param}.#{parameter(ref)}" => value }, context)
+        end
+      end
+
+      Base::Query::OPERATORS.each do |op|
+        define_method(op) do |field, expected, context = nil|
+          apply_operator(op, field, expected, context)
+        end
       end
 
       private
 
-      def resolve
-        return @resolve if @resolve
-        @resolve ||=
+      def response
+        @response ||=
           if @relation[:content_type] == 'Asset'
             @client.assets(
-              { locale: '*' }.merge!(@relation.reject { |k| k == :content_type })
+              { locale: '*' }.merge!(@relation.reject { |k| k == :content_type }).merge!(@options)
             )
           else
-            @client.entries({ locale: '*' }.merge!(@relation))
+            @client.entries({ locale: '*' }.merge!(@relation).merge!(@options))
           end
       end
+
+      def resolve_link(val, depth)
+        return val unless val.is_a?(Hash) && val.dig('sys', 'type') == 'Link'
+        return val unless included = response.includes[val.dig('sys', 'id')]
+
+        resolve_includes(included, depth - 1)
+      end
+
+      def parameter(field, operator: nil, context: nil, locale: false)
+        if sys?(field)
+          "#{field}#{op_param(operator)}"
+        elsif id?(field)
+          "sys.#{field}#{op_param(operator)}"
+        else
+          "#{field_reference(field)}#{locale(context) if locale}#{op_param(operator)}"
+        end
+      end
+
+      def locale(context)
+        ".#{(context || {}).fetch(:locale, 'en-US')}"
+      end
+
+      def op_param(operator)
+        operator ? "[#{operator}]" : ''
+      end
+
+      def field_reference(field)
+        return field if nested?(field)
+
+        "fields.#{field}"
+      end
+
+      def nested?(field)
+        field.to_s.include?('.')
+      end
     end
   end
 end

data/lib/wcc/contentful/store/lazy_cache_store.rb

@@ -2,24 +2,18 @@
 
 module WCC::Contentful::Store
   class LazyCacheStore
-    delegate :find_all, to: :@cdn
-
-    # TODO: https://zube.io/watermarkchurch/development/c/2265
-    #  figure out how to cache the results of a find_by query, ex:
-    #  `find_by('slug' => '/about')`
-    delegate :find_by, to: :@cdn
-
     def initialize(client, cache: nil)
       @cdn = CDNAdapter.new(client)
       @cache = cache || ActiveSupport::Cache::MemoryStore.new
+      @client = client
     end
 
-    def find(key)
+    def find(key, **options)
       found =
         @cache.fetch(key) do
           # if it's not a contentful ID don't hit the API.
           # Store a nil object if we can't find the object on the CDN.
-          (@cdn.find(key) || nil_obj(key)) if key =~ /^\w+$/
+          (@cdn.find(key, options) || nil_obj(key)) if key =~ /^\w+$/
         end
 
       case found.try(:dig, 'sys', 'type')
@@ -30,6 +24,33 @@ module WCC::Contentful::Store
       end
     end
 
+    # TODO: https://github.com/watermarkchurch/wcc-contentful/issues/18
+    #  figure out how to cache the results of a find_by query, ex:
+    #  `find_by('slug' => '/about')`
+    def find_by(content_type:, filter: nil, options: nil)
+      if filter.keys == ['sys.id']
+        # Direct ID lookup, like what we do in `WCC::Contentful::ModelMethods.resolve`
+        # We can return just this item.  Stores are not required to implement :include option.
+        if found = @cache.read(filter['sys.id'])
+          return found
+        end
+      end
+
+      q = find_all(content_type: content_type, options: { limit: 1 }.merge!(options || {}))
+      q = q.apply(filter) if filter
+      q.first
+    end
+
+    def find_all(content_type:, options: nil)
+      Query.new(
+        store: self,
+        client: @client,
+        relation: { content_type: content_type },
+        cache: @cache,
+        options: options
+      )
+    end
+
     # #index is called whenever the sync API comes back with more data.
     def index(json)
       id = json.dig('sys', 'id')
@@ -41,6 +62,7 @@ module WCC::Contentful::Store
 
       # we also set deletes in the cache - no need to go hit the API when we know
       # this is a nil object
+      ensure_hash json
       @cache.write(id, json)
 
       case json.dig('sys', 'type')
@@ -52,6 +74,7 @@ module WCC::Contentful::Store
     end
 
     def set(key, value)
+      ensure_hash value
       old = @cache.read(key)
       @cache.write(key, value)
       old
@@ -72,5 +95,67 @@ module WCC::Contentful::Store
         }
       }
     end
+
+    def ensure_hash(val)
+      raise ArgumentError, 'Value must be a Hash' unless val.is_a?(Hash)
+    end
+
+    class Query < CDNAdapter::Query
+      def initialize(cache:, **extra)
+        super(cache: cache, **extra)
+        @cache = cache
+      end
+
+      private
+
+      def response
+        # Disabling because the superclass already took `@response`
+        # rubocop:disable Naming/MemoizedInstanceVariableName
+        @wrapped_response ||= ResponseWrapper.new(super, @cache)
+        # rubocop:enable Naming/MemoizedInstanceVariableName
+      end
+
+      ResponseWrapper =
+        Struct.new(:response, :cache) do
+          delegate :count, to: :response
+
+          def items
+            @items ||=
+              response.items.map do |item|
+                id = item.dig('sys', 'id')
+                prev = cache.read(id)
+                unless (prev_rev = prev&.dig('sys', 'revision')) &&
+                    (next_rev = item.dig('sys', 'revision')) &&
+                    next_rev < prev_rev
+
+                  cache.write(id, item)
+                end
+
+                item
+              end
+          end
+
+          def includes
+            @includes ||= IncludesWrapper.new(response, cache)
+          end
+        end
+
+      IncludesWrapper =
+        Struct.new(:response, :cache) do
+          def [](id)
+            return unless item = response.includes[id]
+
+            prev = cache.read(id)
+            unless (prev_rev = prev&.dig('sys', 'revision')) &&
+                (next_rev = item.dig('sys', 'revision')) &&
+                next_rev < prev_rev
+
+              cache.write(id, item)
+            end
+
+            item
+          end
+        end
+    end
   end
 end

data/lib/wcc/contentful/store/memory_store.rb

@@ -9,6 +9,7 @@ module WCC::Contentful::Store
 
     def set(key, value)
       value = value.deep_dup.freeze
+      ensure_hash value
       mutex.with_write_lock do
         old = @hash[key]
         @hash[key] = value
@@ -26,43 +27,47 @@ module WCC::Contentful::Store
       mutex.with_read_lock { @hash.keys }
     end
 
-    def find(key)
+    def find(key, **_options)
       mutex.with_read_lock do
         @hash[key]
       end
     end
 
-    def find_all(content_type:)
+    def find_all(content_type:, options: nil)
       relation = mutex.with_read_lock { @hash.values }
 
       relation =
         relation.reject do |v|
-          value_content_type = v.dig('sys', 'contentType', 'sys', 'id')
+          value_content_type = v.try(:dig, 'sys', 'contentType', 'sys', 'id')
           value_content_type.nil? || value_content_type != content_type
         end
-      Query.new(relation)
+      Query.new(self, relation, options)
     end
 
     class Query < Base::Query
       def result
-        @relation.dup
+        return @relation.dup unless @options[:include]
+
+        @relation.map { |e| resolve_includes(e, @options[:include]) }
       end
 
-      def initialize(relation)
+      def initialize(store, relation, options = nil)
+        super(store)
         @relation = relation
+        @options = options || {}
       end
 
       def eq(field, expected, context = nil)
         locale = context[:locale] if context.present?
         locale ||= 'en-US'
-        Query.new(@relation.select do |v|
+        Query.new(@store, @relation.select do |v|
           val = v.dig('fields', field, locale)
           if val.is_a? Array
             val.include?(expected)
           else
             val == expected
           end
-        end)
+        end, @options)
       end
     end
   end

data/lib/wcc/contentful/store/postgres_store.rb

@@ -5,7 +5,7 @@ require 'pg'
 
 module WCC::Contentful::Store
   class PostgresStore < Base
-    def initialize(connection_options = nil)
+    def initialize(_config = nil, connection_options = nil)
       super()
       connection_options ||= { dbname: 'postgres' }
       @conn = PG.connect(connection_options)
@@ -13,8 +13,10 @@ module WCC::Contentful::Store
     end
 
     def set(key, value)
+      ensure_hash value
       result = @conn.exec_prepared('upsert_entry', [key, value.to_json])
       return if result.num_tuples == 0
+
       val = result.getvalue(0, 0)
       JSON.parse(val) if val
     end
@@ -29,30 +31,36 @@ module WCC::Contentful::Store
     def delete(key)
       result = @conn.exec_prepared('delete_by_id', [key])
       return if result.num_tuples == 0
+
       JSON.parse(result.getvalue(0, 1))
     end
 
-    def find(key)
+    def find(key, **_options)
       result = @conn.exec_prepared('select_entry', [key])
       return if result.num_tuples == 0
+
       JSON.parse(result.getvalue(0, 1))
     end
 
-    def find_all(content_type:)
+    def find_all(content_type:, options: nil)
       statement = "WHERE data->'sys'->'contentType'->'sys'->>'id' = $1"
       Query.new(
+        self,
         @conn,
         statement,
-        [content_type]
+        [content_type],
+        options
       )
     end
 
     class Query < Base::Query
-      def initialize(conn, statement = nil, params = nil)
+      def initialize(store, conn, statement = nil, params = nil, options = nil)
+        super(store)
         @conn = conn
         @statement = statement ||
           "WHERE data->'sys'->>'id' IS NOT NULL"
         @params = params || []
+        @options = options || {}
       end
 
       def eq(field, expected, context = nil)
@@ -65,14 +73,17 @@ module WCC::Contentful::Store
           "->$#{push_param(locale, params)} ? $#{push_param(expected, params)}"
 
         Query.new(
+          @store,
           @conn,
           statement,
-          params
+          params,
+          @options
         )
       end
 
       def count
         return @count if @count
+
         statement = 'SELECT count(*) FROM contentful_raw ' + @statement
         result = @conn.exec(statement, @params)
         @count = result.getvalue(0, 0).to_i
@@ -80,27 +91,49 @@ module WCC::Contentful::Store
 
       def first
         return @first if @first
+
         statement = 'SELECT * FROM contentful_raw ' + @statement + ' LIMIT 1'
         result = @conn.exec(statement, @params)
-        JSON.parse(result.getvalue(0, 1))
+        return if result.num_tuples == 0
+
+        resolve_includes(
+          JSON.parse(result.getvalue(0, 1)),
+          @options[:include]
+        )
       end
 
       def map
         arr = []
-        resolve.each { |row| arr << yield(JSON.parse(row['data'])) }
+        resolve.each do |row|
+          arr << yield(
+          resolve_includes(
+            JSON.parse(row['data']),
+            @options[:include]
+          )
+          )
+        end
         arr
       end
 
       def result
         arr = []
-        resolve.each { |row| arr << JSON.parse(row['data']) }
+        resolve.each do |row|
+          arr <<
+            resolve_includes(
+              JSON.parse(row['data']),
+              @options[:include]
+            )
+        end
         arr
       end
 
+      # TODO: override resolve_includes to make it more efficient
+
       private
 
       def resolve
         return @resolved if @resolved
+
         statement = 'SELECT * FROM contentful_raw ' + @statement
         @resolved = @conn.exec(statement, @params)
       end
@@ -120,7 +153,7 @@ module WCC::Contentful::Store
         CREATE INDEX IF NOT EXISTS contentful_raw_value_type ON contentful_raw ((data->'sys'->>'type'));
         CREATE INDEX IF NOT EXISTS contentful_raw_value_content_type ON contentful_raw ((data->'sys'->'contentType'->'sys'->>'id'));
 
-        DROP FUNCTION IF EXISTS "upsert_entry";
+        DROP FUNCTION IF EXISTS "upsert_entry"(_id varchar, _data jsonb);
         CREATE FUNCTION "upsert_entry"(_id varchar, _data jsonb) RETURNS jsonb AS $$
         DECLARE
           prev jsonb;
@@ -133,7 +166,7 @@ module WCC::Contentful::Store
            RETURN prev;
         END;
         $$ LANGUAGE 'plpgsql';
-HEREDOC
+      HEREDOC
       )
 
       conn.prepare('upsert_entry', 'SELECT * FROM upsert_entry($1,$2)')