wcc-contentful 1.1.1 → 1.2.1

data/lib/wcc/contentful/rich_text/node.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::RichText
+  module Node
+    extend ActiveSupport::Concern
+
+    def keys
+      members.map(&:to_s)
+    end
+
+    included do
+      include Enumerable
+
+      alias_method :node_type, :nodeType
+
+      # Make the nodes read-only
+      undef_method :[]=
+      members.each do |member|
+        undef_method("#{member}=")
+      end
+
+      # Override each so it has a Hash-like interface rather than Struct-like.
+      # The goal being to mimic a JSON-parsed hash representation of the raw
+      def each
+        members.map do |key|
+          tuple = [key.to_s, self.[](key)]
+          yield tuple if block_given?
+          tuple
+        end
+      end
+    end
+
+    class_methods do
+      # Default value for node_type covers most cases
+      def node_type
+        name.demodulize.underscore.dasherize
+      end
+
+      def tokenize(raw, context = nil)
+        raise ArgumentError, "Expected '#{node_type}', got '#{raw['nodeType']}'" unless raw['nodeType'] == node_type
+
+        values =
+          members.map do |symbol|
+            val = raw[symbol.to_s]
+
+            case symbol
+            when :content
+              WCC::Contentful::RichText.tokenize(val, context)
+              # when :data
+              # TODO: resolve links...
+            else
+              val
+            end
+          end
+
+        new(*values)
+      end
+    end
+  end
+end

data/lib/wcc/contentful/rich_text.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative './rich_text/node'
+
+##
+# This module contains a number of structs representing nodes in a Contentful
+# rich text field.  When the Model layer parses a Rich Text field from
+# Contentful, it is turned into a WCC::Contentful::RichText::Document node.
+# The {WCC::Contentful::RichText::Document#content content} method of this
+# node is an Array containing paragraph, blockquote, entry, and other nodes.
+#
+# The various structs in the RichText object model are designed to mimic the
+# Hash interface, so that the indexing operator `#[]` and the `#dig` method
+# can be used to traverse the data.  The data can also be accessed by the
+# attribute reader methods defined on the structs.  Both of these are considered
+# part of the public API of the model and will not change.
+#
+# In a future release we plan to implement automatic link resolution.  When that
+# happens, the `.data` attribute of embedded entries and assets will return a
+# new class that is able to resolve the `.target` automatically into a full
+# entry or asset.  This future class will still respect the hash accessor methods
+# `#[]`, `#dig`, `#keys`, and `#each`, so it is safe to use those.
+module WCC::Contentful::RichText
+  ##
+  # Recursively converts a raw JSON-parsed hash into the RichText object model.
+  def self.tokenize(raw, context = nil)
+    return unless raw
+    return raw.map { |c| tokenize(c, context) } if raw.is_a?(Array)
+
+    klass =
+      case raw['nodeType']
+      when 'document'
+        Document
+      when 'paragraph'
+        Paragraph
+      when 'blockquote'
+        Blockquote
+      when 'text'
+        Text
+      when 'embedded-entry-inline'
+        EmbeddedEntryInline
+      when 'embedded-entry-block'
+        EmbeddedEntryBlock
+      when 'embedded-asset-block'
+        EmbeddedAssetBlock
+      when /heading-(\d+)/
+        size = Regexp.last_match(1)
+        const_get("Heading#{size}")
+      else
+        Unknown
+      end
+
+    klass.tokenize(raw, context)
+  end
+
+  Document =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  Paragraph =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  Blockquote =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  Text =
+    Struct.new(:nodeType, :value, :marks, :data) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  EmbeddedEntryInline =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  EmbeddedEntryBlock =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  EmbeddedAssetBlock =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+
+  (1..5).each do |i|
+    struct =
+      Struct.new(:nodeType, :data, :content) do
+        include WCC::Contentful::RichText::Node
+      end
+    sz = i
+    struct.define_singleton_method(:node_type) { "heading-#{sz}" }
+    const_set("Heading#{sz}", struct)
+  end
+
+  Unknown =
+    Struct.new(:nodeType, :data, :content) do
+      include WCC::Contentful::RichText::Node
+    end
+end

data/lib/wcc/contentful/rspec.rb

@@ -13,9 +13,7 @@ module WCC::Contentful::RSpec
   # stubs the Model API to return that content type for `.find` and `.find_by`
   # query methods.
   def contentful_stub(const, **attrs)
-    unless const.respond_to?(:content_type_definition)
-      const = WCC::Contentful::Model.resolve_constant(const.to_s)
-    end
+    const = WCC::Contentful::Model.resolve_constant(const.to_s) unless const.respond_to?(:content_type_definition)
     instance = contentful_create(const, **attrs)
 
     # mimic what's going on inside model_singleton_methods.rb

data/lib/wcc/contentful/simple_client/response.rb

@@ -6,9 +6,7 @@ class WCC::Contentful::SimpleClient
   class Response
     include ::WCC::Contentful::Instrumentation
 
-    attr_reader :raw_response
-    attr_reader :client
-    attr_reader :request
+    attr_reader :raw_response, :client, :request
 
     delegate :status, to: :raw_response
     alias_method :code, :status
@@ -26,7 +24,7 @@ class WCC::Contentful::SimpleClient
     def error_message
       parsed_message =
         begin
-          raw.dig('message')
+          raw['message']
         rescue JSON::ParserError
           nil
         end
@@ -49,7 +47,6 @@ class WCC::Contentful::SimpleClient
 
     def next_page
       return unless next_page?
-      return @next_page if @next_page
 
       query = (@request[:query] || {}).merge({
         skip: page_items.length + skip
@@ -58,7 +55,7 @@ class WCC::Contentful::SimpleClient
         _instrument 'page', url: @request[:url], query: query do
           @client.get(@request[:url], query)
         end
-      @next_page = np.assert_ok!
+      np.assert_ok!
     end
 
     def initialize(client, request, raw_response)
@@ -77,16 +74,7 @@ class WCC::Contentful::SimpleClient
     def each_page(&block)
       raise ArgumentError, 'Not a collection response' unless page_items
 
-      ret =
-        Enumerator.new do |y|
-          y << self
-
-          if next_page?
-            next_page.each_page.each do |page|
-              y << page
-            end
-          end
-        end
+      ret = PaginatingEnumerable.new(self)
 
       if block_given?
         ret.map(&block)
@@ -115,14 +103,9 @@ class WCC::Contentful::SimpleClient
 
     def includes
       @includes ||=
-        raw.dig('includes')&.each_with_object({}) do |(_t, entries), h|
+        raw['includes']&.each_with_object({}) do |(_t, entries), h|
           entries.each { |e| h[e.dig('sys', 'id')] = e }
         end || {}
-
-      return @includes unless @next_page
-
-      # This could be more efficient - maybe not worth worrying about
-      @includes.merge(@next_page.includes)
     end
   end
 
@@ -144,8 +127,8 @@ class WCC::Contentful::SimpleClient
           @client.get(url)
         end
 
-      @next_page ||= SyncResponse.new(next_page)
-      @next_page.assert_ok!
+      next_page = SyncResponse.new(next_page)
+      next_page.assert_ok!
     end
 
     def next_sync_token
@@ -160,16 +143,7 @@ class WCC::Contentful::SimpleClient
     def each_page
       raise ArgumentError, 'Not a collection response' unless page_items
 
-      ret =
-        Enumerator.new do |y|
-          y << self
-
-          if next_page?
-            next_page.each_page.each do |page|
-              y << page
-            end
-          end
-        end
+      ret = PaginatingEnumerable.new(self)
 
       if block_given?
         ret.map(&block)
@@ -190,6 +164,26 @@ class WCC::Contentful::SimpleClient
     end
   end
 
+  class PaginatingEnumerable
+    include Enumerable
+
+    def initialize(initial_page)
+      raise ArgumentError, 'Must provide initial page' unless initial_page.present?
+
+      @initial_page = initial_page
+    end
+
+    def each
+      page = @initial_page
+      yield page
+
+      while page.next_page?
+        page = page.next_page
+        yield page
+      end
+    end
+  end
+
   class ApiError < StandardError
     attr_reader :response
 

data/lib/wcc/contentful/simple_client.rb

@@ -24,8 +24,7 @@ module WCC::Contentful
   class SimpleClient
     include WCC::Contentful::Instrumentation
 
-    attr_reader :api_url
-    attr_reader :space
+    attr_reader :api_url, :space
 
     # Creates a new SimpleClient with the given configuration.
     #
@@ -41,7 +40,7 @@ module WCC::Contentful
     # @option options [Number] rate_limit_wait_timeout The maximum time to block the thread waiting
     #   on a rate limit response.  By default will wait for one 429 and then fail on the second 429.
     def initialize(api_url:, space:, access_token:, **options)
-      @api_url = URI.join(api_url, '/spaces/', space + '/')
+      @api_url = URI.join(api_url, '/spaces/', "#{space}/")
       @space = space
       @access_token = access_token
 
@@ -57,7 +56,7 @@ module WCC::Contentful
 
       return unless options[:environment].present?
 
-      @api_url = URI.join(@api_url, 'environments/', options[:environment] + '/')
+      @api_url = URI.join(@api_url, 'environments/', "#{options[:environment]}/")
     end
 
     # performs an HTTP GET request to the specified path within the configured
@@ -84,15 +83,13 @@ module WCC::Contentful
       case adapter
       when nil
         ADAPTERS.each do |a, spec|
-          begin
-            gem(*spec)
-            return load_adapter(a)
-          rescue Gem::LoadError
-            next
-          end
+          gem(*spec)
+          return load_adapter(a)
+        rescue Gem::LoadError
+          next
         end
-        raise ArgumentError, 'Unable to load adapter!  Please install one of '\
-          "#{ADAPTERS.values.map(&:join).join(',')}"
+        raise ArgumentError, 'Unable to load adapter!  Please install one of ' \
+                             "#{ADAPTERS.values.map(&:join).join(',')}"
       when :faraday
         require 'faraday'
         ::Faraday.new do |faraday|
@@ -104,8 +101,8 @@ module WCC::Contentful
         TyphoeusAdapter.new
       else
         unless adapter.respond_to?(:get)
-          raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please "\
-            "pass use one of #{ADAPTERS.keys} or create a Faraday-compatible adapter"
+          raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please " \
+                               "pass use one of #{ADAPTERS.keys} or create a Faraday-compatible adapter"
         end
         adapter
       end

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

@@ -61,11 +61,11 @@ module WCC::Contentful::Store
             set(json.dig('sys', 'id'), json)
           end
 
-        if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision'))
-          if next_rev < prev_rev
-            # Uh oh! we overwrote an entry with a prior revision.  Put the previous back.
-            return index(prev)
-          end
+        if (prev_rev = prev&.dig('sys', 'revision')) &&
+            (next_rev = json.dig('sys', 'revision')) &&
+            (next_rev < prev_rev)
+          # Uh oh! we overwrote an entry with a prior revision.  Put the previous back.
+          return index(prev)
         end
 
         case type

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

@@ -3,7 +3,7 @@
 module WCC::Contentful::Store
   class CDNAdapter
     include WCC::Contentful::Store::Interface
-    # Note: CDNAdapter should not instrument store events cause it's not a store.
+    # NOTE: CDNAdapter should not instrument store events cause it's not a store.
 
     attr_writer :client, :preview_client
 
@@ -72,9 +72,13 @@ module WCC::Contentful::Store
       delegate :count, to: :response
 
       def to_enum
-        return response.items unless @options[:include]
+        return response.each_page.flat_map(&:page_items) unless @options[:include]
 
-        response.items.map { |e| resolve_includes(e, @options[:include]) }
+        response.each_page
+          .flat_map { |page| page.page_items.each_with_object(page).to_a }
+          .map do |e, page|
+            resolve_includes(e, page.includes, depth: @options[:include])
+          end
       end
 
       def initialize(store, client:, relation:, options: nil, **extra)
@@ -160,18 +164,18 @@ module WCC::Contentful::Store
           end
       end
 
-      def resolve_includes(entry, depth)
+      def resolve_includes(entry, includes, depth:)
         return entry unless entry && depth && depth > 0
 
         # Dig links out of response.includes and insert them into the entry
         WCC::Contentful::LinkVisitor.new(entry, :Link, depth: depth - 1).map! do |val|
-          resolve_link(val)
+          resolve_link(val, includes)
         end
       end
 
-      def resolve_link(val)
+      def resolve_link(val, includes)
         return val unless val.is_a?(Hash) && val.dig('sys', 'type') == 'Link'
-        return val unless included = response.includes[val.dig('sys', 'id')]
+        return val unless included = includes[val.dig('sys', 'id')]
 
         included
       end

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

@@ -90,7 +90,7 @@ module WCC::Contentful::Store
         next if m[0].respond_to?(:call)
 
         raise ArgumentError, "The middleware '#{m[0]&.try(:name) || m[0]}' cannot be applied!  " \
-          'It must respond to :call'
+                             'It must respond to :call'
       end
 
       validate_store!(store)

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

@@ -41,8 +41,8 @@ module WCC::Contentful::Store
     SUPPORTED_OPS = %i[eq ne in nin].freeze
 
     def execute(query)
-      (query.conditions.map(&:op) - SUPPORTED_OPS).each do |op|
-        raise ArgumentError, "Operator :#{op} not supported"
+      if bad_op = (query.conditions.map(&:op) - SUPPORTED_OPS).first
+        raise ArgumentError, "Operator :#{bad_op} not supported"
       end
 
       relation = mutex.with_read_lock { @hash.values }

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

@@ -45,12 +45,9 @@ module WCC::Contentful::Store
           JSON.parse(val) if val
         end
 
-      if views_need_update?(value, previous_value)
-        # mark dirty - we need to refresh the materialized view
-        unless mutex.with_read_lock { @dirty }
-          _instrument 'mark_dirty'
-          mutex.with_write_lock { @dirty = true }
-        end
+      if views_need_update?(value, previous_value) && !mutex.with_read_lock { @dirty }
+        _instrument 'mark_dirty'
+        mutex.with_write_lock { @dirty = true }
       end
 
       previous_value
@@ -105,7 +102,7 @@ module WCC::Contentful::Store
         end
       end
 
-      logger&.debug('[PostgresStore] ' + statement + "\n" + params.inspect)
+      logger&.debug("[PostgresStore] #{statement}\n#{params.inspect}")
       _instrument 'exec' do
         @connection_pool.with { |conn| conn.exec(statement, params) }
       end
@@ -231,16 +228,12 @@ module WCC::Contentful::Store
         end
 
         statement =
-          select_statement +
-          " FROM #{table} AS t \n" +
-          joins.join("\n") + "\n" +
-          statement +
-          (limit_statement || '')
+          "#{select_statement} FROM #{table} AS t \n#{joins.join("\n")}\n#{statement}#{limit_statement || ''}"
 
         [statement, params]
       end
 
-      def _eq(path, expected, params)
+      def _eq(path, expected, params) # rubocop:disable Layout/LineContinuationLeadingSpace
         return " AND t.id = $#{push_param(expected, params)}" if path == %w[sys id]
 
         if path[3] == 'sys'
@@ -248,12 +241,12 @@ module WCC::Contentful::Store
           # into it to detect whether it contains `{ "sys": { "id" => expected } }`
           expected = { 'sys' => { path[4] => expected } }.to_json
           return ' AND fn_contentful_jsonb_any_to_jsonb_array(t.data->' \
-            "#{quote_parameter_path(path.take(3))}) @> " \
-            "jsonb_build_array($#{push_param(expected, params)}::jsonb)"
+                 "#{quote_parameter_path(path.take(3))}) @> " \
+                 "jsonb_build_array($#{push_param(expected, params)}::jsonb)"
         end
 
-        " AND t.data->#{quote_parameter_path(path)}" \
-          " @> to_jsonb($#{push_param(expected, params)})"
+        " AND t.data->#{quote_parameter_path(path)} " \
+          "@> to_jsonb($#{push_param(expected, params)})"
       end
 
       PARAM_TYPES = {
@@ -292,7 +285,7 @@ module WCC::Contentful::Store
       def push_join(_path, joins)
         table_alias = "s#{joins.length}"
         joins << "JOIN contentful_raw AS #{table_alias} ON " \
-          "#{table_alias}.id=ANY(t.links)"
+                 "#{table_alias}.id=ANY(t.links)"
         table_alias
       end
     end
@@ -326,8 +319,8 @@ module WCC::Contentful::Store
       end
 
       def schema_ensured?(conn)
-        result = conn.exec('SELECT version FROM wcc_contentful_schema_version' \
-          ' ORDER BY version DESC LIMIT 1')
+        result = conn.exec('SELECT version FROM wcc_contentful_schema_version ' \
+                           'ORDER BY version DESC LIMIT 1')
         return false if result.num_tuples == 0
 
         result[0]['version'].to_i >= EXPECTED_VERSION
@@ -339,8 +332,8 @@ module WCC::Contentful::Store
       def ensure_schema(conn)
         result =
           begin
-            conn.exec('SELECT version FROM wcc_contentful_schema_version' \
-          ' ORDER BY version DESC')
+            conn.exec('SELECT version FROM wcc_contentful_schema_version ' \
+                      'ORDER BY version DESC')
           rescue PG::UndefinedTable
             []
           end

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

@@ -36,7 +36,7 @@ module WCC::Contentful::Store
 
     FALSE_VALUES = [
       false, 0,
-      '0', :"0",
+      '0', :'0',
       'f', :f,
       'F', :F,
       'false', :false, # rubocop:disable Lint/BooleanSymbol
@@ -237,7 +237,7 @@ module WCC::Contentful::Store
 
     Condition =
       Struct.new(:path, :op, :expected) do
-        LINK_KEYS = %w[id type linkType].freeze
+        LINK_KEYS = %w[id type linkType].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
 
         def path_tuples
           @path_tuples ||=

data/lib/wcc/contentful/store/rspec_examples/include_param.rb

@@ -15,10 +15,12 @@ RSpec.shared_examples 'supports include param' do |feature_set|
         'fields' => {
           'name' => { 'en-US' => 'root' },
           'link' => { 'en-US' => make_link_to('deep1') },
-          'links' => { 'en-US' => [
-            make_link_to('shallow3'),
-            make_link_to('deep2')
-          ] }
+          'links' => {
+            'en-US' => [
+              make_link_to('shallow3'),
+              make_link_to('deep2')
+            ]
+          }
         }
       }
     end

data/lib/wcc/contentful/store/rspec_examples/operators.rb

@@ -40,7 +40,7 @@ RSpec.shared_examples 'operators' do |feature_set|
     end
   end
 
-  supported_operators.each do |op, value|
+  supported_operators.each do |op, value| # rubocop:disable Style/CombinableLoops
     next unless value
 
     it_behaves_like "supports :#{op} operator" do

data/lib/wcc/contentful/sync_engine.rb

@@ -31,15 +31,18 @@ module WCC::Contentful
       (@state&.dup || token_wrapper_factory(nil)).freeze
     end
 
-    attr_reader :store
-    attr_reader :client
+    attr_reader :store, :client, :options
 
     def should_sync?
       store&.index?
     end
 
-    def initialize(state: nil, store: nil, client: nil, key: nil)
-      @state_key = key || "sync:#{object_id}"
+    def initialize(client: nil, store: nil, state: nil, **options)
+      @options = {
+        key: "sync:#{object_id}"
+      }.merge!(options).freeze
+
+      @state_key = @options[:key] || "sync:#{object_id}"
       @client = client || WCC::Contentful::Services.instance.client
       @mutex = Mutex.new
 
@@ -53,9 +56,7 @@ module WCC::Contentful
       if state
         @state = token_wrapper_factory(state)
         raise ArgumentError, ':state param must be a String or Hash' unless @state.is_a? Hash
-        unless @state.dig('sys', 'type') == 'token'
-          raise ArgumentError, ':state param must be of sys.type = "token"'
-        end
+        raise ArgumentError, ':state param must be of sys.type = "token"' unless @state.dig('sys', 'type') == 'token'
       end
       raise ArgumentError, 'either :state or :store must be provided' unless @state || @store
     end
@@ -144,8 +145,12 @@ module WCC::Contentful
           return unless sync_engine&.should_sync?
 
           up_to_id = nil
-          up_to_id = event[:up_to_id] || event.dig('sys', 'id') if event
-          sync!(up_to_id: up_to_id)
+          retry_count = 0
+          if event
+            up_to_id = event[:up_to_id] || event.dig('sys', 'id')
+            retry_count = event[:retry_count] if event[:retry_count]
+          end
+          sync!(up_to_id: up_to_id, retry_count: retry_count)
         end
 
         # Calls the Contentful Sync API and updates the configured store with the returned
@@ -156,21 +161,32 @@ module WCC::Contentful
         #  If we don't find this ID in the sync data, then drop a job to try
         #  the sync again after a few minutes.
         #
-        def sync!(up_to_id: nil)
+        def sync!(up_to_id: nil, retry_count: 0)
           id_found, count = sync_engine.next(up_to_id: up_to_id)
 
           next_sync_token = sync_engine.state['token']
 
           logger.info "Synced #{count} entries.  Next sync token:\n  #{next_sync_token}"
-          logger.info "Should enqueue again? [#{!id_found}]"
-          # Passing nil to only enqueue the job 1 more time
-          sync_later!(up_to_id: nil) unless id_found
+          unless id_found
+            if retry_count >= configuration.sync_retry_limit
+              logger.error "Unable to find item with id '#{up_to_id}' on the Sync API.  " \
+                           "Abandoning after #{retry_count} retries."
+            else
+              wait = (2**retry_count) * configuration.sync_retry_wait.seconds
+              logger.info "Unable to find item with id '#{up_to_id}' on the Sync API.  " \
+                          "Retrying after #{wait.inspect} " \
+                          "(#{configuration.sync_retry_limit - retry_count} retries remaining)"
+
+              self.class.set(wait: wait)
+                .perform_later(up_to_id: up_to_id, retry_count: retry_count + 1)
+            end
+          end
           next_sync_token
         end
 
-        # Drops an ActiveJob job to invoke WCC::Contentful.sync! after a given amount
+        # Enqueues an ActiveJob job to invoke WCC::Contentful.sync! after a given amount
         # of time.
-        def sync_later!(up_to_id: nil, wait: 10.minutes)
+        def sync_later!(up_to_id: nil, wait: 10.seconds)
           self.class.set(wait: wait)
             .perform_later(up_to_id: up_to_id)
         end