wcc-contentful 1.2.0 → 1.3.1

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# The CDN SimpleClient accesses 'https://cdn.contentful.com' to get raw
+# JSON responses.  It exposes methods to query entries, assets, and content_types.
+# The responses are instances of WCC::Contentful::SimpleClient::Response
+# which handles paging automatically.
+#
+# @api Client
+class WCC::Contentful::SimpleClient::Cdn < WCC::Contentful::SimpleClient
+  def initialize(space:, access_token:, **options)
+    super(
+      api_url: options[:api_url] || 'https://cdn.contentful.com/',
+      space: space,
+      access_token: access_token,
+      **options
+    )
+  end
+
+  def client_type
+    'cdn'
+  end
+
+  # Gets an entry by ID
+  def entry(key, query = {})
+    resp =
+      _instrument 'entries', id: key, type: 'Entry', query: query do
+        get("entries/#{key}", query)
+      end
+    resp.assert_ok!
+  end
+
+  # Queries entries with optional query parameters
+  def entries(query = {})
+    resp =
+      _instrument 'entries', type: 'Entry', query: query do
+        get('entries', query)
+      end
+    resp.assert_ok!
+  end
+
+  # Gets an asset by ID
+  def asset(key, query = {})
+    resp =
+      _instrument 'entries', type: 'Asset', id: key, query: query do
+        get("assets/#{key}", query)
+      end
+    resp.assert_ok!
+  end
+
+  # Queries assets with optional query parameters
+  def assets(query = {})
+    resp =
+      _instrument 'entries', type: 'Asset', query: query do
+        get('assets', query)
+      end
+    resp.assert_ok!
+  end
+
+  # Queries content types with optional query parameters
+  def content_types(query = {})
+    resp =
+      _instrument 'content_types', query: query do
+        get('content_types', query)
+      end
+    resp.assert_ok!
+  end
+
+  # Accesses the Sync API to get a list of items that have changed since
+  # the last sync.  Accepts a block that receives each changed item, and returns
+  # the next sync token.
+  #
+  # If `sync_token` is nil, an initial sync is performed.
+  #
+  # @return String the next sync token parsed from nextSyncUrl
+  # @example
+  #    my_sync_token = storage.get('sync_token')
+  #    my_sync_token = client.sync(sync_token: my_sync_token) do |item|
+  #      storage.put(item.dig('sys', 'id'), item) }
+  #    end
+  #    storage.put('sync_token', my_sync_token)
+  def sync(sync_token: nil, **query, &block)
+    return sync_old(sync_token: sync_token, **query) unless block_given?
+
+    sync_token =
+      if sync_token
+        { sync_token: sync_token }
+      else
+        { initial: true }
+      end
+    query = query.merge(sync_token)
+
+    _instrument 'sync', sync_token: sync_token, query: query do
+      resp = get('sync', query)
+      resp = SyncResponse.new(resp)
+      resp.assert_ok!
+
+      resp.each_page do |page|
+        page.page_items.each(&block)
+        sync_token = resp.next_sync_token
+      end
+    end
+
+    sync_token
+  end
+
+  private
+
+  def sync_old(sync_token: nil, **query)
+    ActiveSupport::Deprecation.warn('Sync without a block is deprecated, please use new block syntax instead')
+
+    sync_token =
+      if sync_token
+        { sync_token: sync_token }
+      else
+        { initial: true }
+      end
+    query = query.merge(sync_token)
+
+    resp =
+      _instrument 'sync', sync_token: sync_token, query: query do
+        get('sync', query)
+      end
+    resp = SyncResponse.new(resp, memoize: true)
+    resp.assert_ok!
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# @api Client
+class WCC::Contentful::SimpleClient::Preview < WCC::Contentful::SimpleClient::Cdn
+  def initialize(space:, preview_token:, **options)
+    super(
+      **options,
+      api_url: options[:preview_api_url] || 'https://preview.contentful.com/',
+      space: space,
+      access_token: preview_token
+    )
+  end
+
+  def client_type
+    'preview'
+  end
+end

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
@@ -105,15 +103,16 @@ 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 || {}
     end
   end
 
   class SyncResponse < Response
-    def initialize(response)
+    def initialize(response, memoize: false)
       super(response.client, response.request, response.raw_response)
+      @memoize = memoize
     end
 
     def next_page?
@@ -122,6 +121,7 @@ class WCC::Contentful::SimpleClient
 
     def next_page
       return unless next_page?
+      return @next_page if @next_page
 
       url = raw['nextPageUrl']
       next_page =
@@ -131,26 +131,31 @@ class WCC::Contentful::SimpleClient
 
       next_page = SyncResponse.new(next_page)
       next_page.assert_ok!
+      @next_page = next_page if @memoize
+      next_page
     end
 
     def next_sync_token
-      # If we haven't grabbed the next page yet, then our next "sync" will be getting
-      # the next page.  We could just as easily call sync again with that token.
-      @next_page&.next_sync_token ||
-        @next_sync_token ||= SyncResponse.parse_sync_token(
-          raw['nextPageUrl'] || raw['nextSyncUrl']
-        )
-    end
-
-    def each_page
-      raise ArgumentError, 'Not a collection response' unless page_items
+      # If we have iterated some pages, return the sync token of the final
+      # page that was iterated.  Do this without maintaining a reference to
+      # all the pages.
+      return @last_sync_token if @last_sync_token
 
-      ret = PaginatingEnumerable.new(self)
+      SyncResponse.parse_sync_token(raw['nextPageUrl'] || raw['nextSyncUrl'])
+    end
 
+    def each_page(&block)
       if block_given?
-        ret.map(&block)
+        super do |page|
+          @last_sync_token = page.next_sync_token
+
+          yield page
+        end
       else
-        ret.lazy
+        super.map do |page|
+          @last_sync_token = page.next_sync_token
+          page
+        end
       end
     end
 

data/lib/wcc/contentful/simple_client.rb

@@ -2,6 +2,8 @@
 
 require_relative 'simple_client/response'
 require_relative 'simple_client/management'
+require_relative 'simple_client/cdn'
+require_relative 'simple_client/preview'
 require_relative 'instrumentation'
 
 module WCC::Contentful
@@ -24,8 +26,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 +42,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 +58,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 +85,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 +103,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
@@ -149,109 +148,5 @@ module WCC::Contentful
         return resp
       end
     end
-
-    # The CDN SimpleClient accesses 'https://cdn.contentful.com' to get raw
-    # JSON responses.  It exposes methods to query entries, assets, and content_types.
-    # The responses are instances of WCC::Contentful::SimpleClient::Response
-    # which handles paging automatically.
-    #
-    # @api Client
-    class Cdn < SimpleClient
-      def initialize(space:, access_token:, **options)
-        super(
-          api_url: options[:api_url] || 'https://cdn.contentful.com/',
-          space: space,
-          access_token: access_token,
-          **options
-        )
-      end
-
-      def client_type
-        'cdn'
-      end
-
-      # Gets an entry by ID
-      def entry(key, query = {})
-        resp =
-          _instrument 'entries', id: key, type: 'Entry', query: query do
-            get("entries/#{key}", query)
-          end
-        resp.assert_ok!
-      end
-
-      # Queries entries with optional query parameters
-      def entries(query = {})
-        resp =
-          _instrument 'entries', type: 'Entry', query: query do
-            get('entries', query)
-          end
-        resp.assert_ok!
-      end
-
-      # Gets an asset by ID
-      def asset(key, query = {})
-        resp =
-          _instrument 'entries', type: 'Asset', id: key, query: query do
-            get("assets/#{key}", query)
-          end
-        resp.assert_ok!
-      end
-
-      # Queries assets with optional query parameters
-      def assets(query = {})
-        resp =
-          _instrument 'entries', type: 'Asset', query: query do
-            get('assets', query)
-          end
-        resp.assert_ok!
-      end
-
-      # Queries content types with optional query parameters
-      def content_types(query = {})
-        resp =
-          _instrument 'content_types', query: query do
-            get('content_types', query)
-          end
-        resp.assert_ok!
-      end
-
-      # Accesses the Sync API to get a list of items that have changed since
-      # the last sync.
-      #
-      # If `sync_token` is nil, an initial sync is performed.
-      # Returns a WCC::Contentful::SimpleClient::SyncResponse
-      # which handles paging automatically.
-      def sync(sync_token: nil, **query)
-        sync_token =
-          if sync_token
-            { sync_token: sync_token }
-          else
-            { initial: true }
-          end
-        query = query.merge(sync_token)
-        resp =
-          _instrument 'sync', sync_token: sync_token, query: query do
-            get('sync', query)
-          end
-        resp = SyncResponse.new(resp)
-        resp.assert_ok!
-      end
-    end
-
-    # @api Client
-    class Preview < Cdn
-      def initialize(space:, preview_token:, **options)
-        super(
-          **options,
-          api_url: options[:preview_api_url] || 'https://preview.contentful.com/',
-          space: space,
-          access_token: preview_token
-        )
-      end
-
-      def client_type
-        'preview'
-      end
-    end
   end
 end

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

@@ -50,30 +50,30 @@ module WCC::Contentful::Store
     # implementation calls into #set and #delete to perform the appropriate
     # operations in the store.
     def index(json)
+      # This implementation assumes that #delete and #set are individually thread-safe.
+      # No mutex is needed so long as the revisions are accurate.
       # Subclasses can override to do this in a more performant thread-safe way.
       # Example: postgres_store could do this in a stored procedure for speed
-      mutex.with_write_lock do
-        prev =
-          case type = json.dig('sys', 'type')
-          when 'DeletedEntry', 'DeletedAsset'
-            delete(json.dig('sys', 'id'))
-          else
-            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
-        end
-
-        case type
+      prev =
+        case type = json.dig('sys', 'type')
         when 'DeletedEntry', 'DeletedAsset'
-          nil
+          delete(json.dig('sys', 'id'))
         else
-          json
+          set(json.dig('sys', 'id'), json)
         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
+      when 'DeletedEntry', 'DeletedAsset'
+        nil
+      else
+        json
       end
     end
 
@@ -107,17 +107,9 @@ module WCC::Contentful::Store
       )
     end
 
-    def initialize
-      @mutex = Concurrent::ReentrantReadWriteLock.new
-    end
-
     def ensure_hash(val)
       raise ArgumentError, 'Value must be a Hash' unless val.is_a?(Hash)
     end
-
-    private
-
-    attr_reader :mutex
   end
 end
 

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
 

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

@@ -9,13 +9,15 @@ module WCC::Contentful::Store
   class MemoryStore < Base
     def initialize
       super
+
+      @mutex = Concurrent::ReentrantReadWriteLock.new
       @hash = {}
     end
 
     def set(key, value)
       value = value.deep_dup.freeze
       ensure_hash value
-      mutex.with_write_lock do
+      @mutex.with_write_lock do
         old = @hash[key]
         @hash[key] = value
         old
@@ -23,17 +25,17 @@ module WCC::Contentful::Store
     end
 
     def delete(key)
-      mutex.with_write_lock do
+      @mutex.with_write_lock do
         @hash.delete(key)
       end
     end
 
     def keys
-      mutex.with_read_lock { @hash.keys }
+      @mutex.with_read_lock { @hash.keys }
     end
 
     def find(key, **_options)
-      mutex.with_read_lock do
+      @mutex.with_read_lock do
         @hash[key]
       end
     end
@@ -41,11 +43,12 @@ 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 }
+      # Since @hash.values returns a new array, we only need to lock here
+      relation = @mutex.with_read_lock { @hash.values }
 
       # relation is an enumerable that we apply conditions to in the form of
       #  Enumerable#select and Enumerable#reject.