wcc-contentful 0.1.0 → 0.2.0

data/lib/wcc/contentful/simple_client.rb

@@ -1,17 +1,24 @@
 # frozen_string_literal: true
 
-require 'http'
-
 require_relative 'simple_client/response'
 
 module WCC::Contentful
+  ##
+  # The SimpleClient accesses the Contentful CDN to get JSON responses,
+  # returning the raw JSON data as a parsed hash.
+  # It can be configured to access any API url and exposes only a single method,
+  # `get`.  This method returns a WCC::Contentful::SimpleClient::Response
+  # that handles paging automatically.
+  #
+  # The SimpleClient by default uses 'http' to perform the gets, but any HTTP
+  # client can be injected by passing a proc as the `adapter:` option.
   class SimpleClient
     def initialize(api_url:, space:, access_token:, **options)
       @api_url = URI.join(api_url, '/spaces/', space + '/')
       @space = space
       @access_token = access_token
 
-      @get_http = options[:override_get_http] if options[:override_get_http].present?
+      @get_http = SimpleClient.load_adapter(options[:adapter])
 
       @options = options
       @query_defaults = {}
@@ -26,6 +33,39 @@ module WCC::Contentful
         get_http(url, query))
     end
 
+    ADAPTERS = {
+      http: ['http', '> 1.0', '< 3.0'],
+      typhoeus: ['typhoeus', '~> 1.0']
+    }.freeze
+
+    def self.load_adapter(adapter)
+      case adapter
+      when nil
+        ADAPTERS.each do |a, spec|
+          begin
+            gem(*spec)
+            return load_adapter(a)
+          rescue Gem::LoadError
+            next
+          end
+        end
+        raise ArgumentError, 'Unable to load adapter!  Please install one of '\
+          "#{ADAPTERS.values.map(&:join).join(',')}"
+      when :http
+        require_relative 'simple_client/http_adapter'
+        HttpAdapter.new
+      when :typhoeus
+        require_relative 'simple_client/typhoeus_adapter'
+        TyphoeusAdapter.new
+      else
+        unless adapter.respond_to?(:call)
+          raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please "\
+            "pass a proc or use one of #{ADAPTERS.keys}"
+        end
+        adapter
+      end
+    end
+
     private
 
     def get_http(url, query, headers = {}, proxy = {})
@@ -36,27 +76,19 @@ module WCC::Contentful
       q = @query_defaults.dup
       q = q.merge(query) if query
 
-      resp =
-        if @get_http
-          @get_http.call(url, q, headers, proxy)
-        else
-          default_get_http(url, q, headers, proxy)
-        end
+      resp = @get_http.call(url, q, headers, proxy)
+
       if [301, 302, 307].include?(resp.code) && !@options[:no_follow_redirects]
         resp = get_http(resp.headers['location'], nil, headers, proxy)
       end
       resp
     end
 
-    def default_get_http(url, query, headers = {}, proxy = {})
-      if proxy[:host]
-        HTTP[headers].via(proxy[:host], proxy[:port], proxy[:username], proxy[:password])
-          .get(url, params: query)
-      else
-        HTTP[headers].get(url, params: query)
-      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.
     class Cdn < SimpleClient
       def initialize(space:, access_token:, **options)
         super(
@@ -67,31 +99,48 @@ module WCC::Contentful
         )
       end
 
+      ##
+      # Gets an entry by ID
       def entry(key, query = {})
         resp = get("entries/#{key}", query)
         resp.assert_ok!
       end
 
+      ##
+      # Queries entries with optional query parameters
       def entries(query = {})
         resp = get('entries', query)
         resp.assert_ok!
       end
 
+      ##
+      # Gets an asset by ID
       def asset(key, query = {})
         resp = get("assets/#{key}", query)
         resp.assert_ok!
       end
 
+      ##
+      # Queries assets with optional query parameters
       def assets(query = {})
         resp = get('assets', query)
         resp.assert_ok!
       end
 
+      ##
+      # Queries content types with optional query parameters
       def content_types(query = {})
         resp = get('content_types', query)
         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

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

@@ -0,0 +1,89 @@
+
+# frozen_string_literal: true
+
+module WCC::Contentful::Store
+  class Base
+    def find(_id)
+      raise NotImplementedError, "#{self.class} does not implement #find"
+    end
+
+    def set(_id, _value)
+      raise NotImplementedError, "#{self.class} does not implement #set"
+    end
+
+    def delete(_id)
+      raise NotImplementedError, "#{self.class} does not implement #delete"
+    end
+
+    def index(json)
+      # 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
+        when 'DeletedEntry', 'DeletedAsset'
+          nil
+        else
+          json
+        end
+      end
+    end
+
+    def find_by(content_type:, filter: nil)
+      # default implementation - can be overridden
+      q = find_all(content_type: content_type)
+      q = q.apply(filter) if filter
+      q.first
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    def find_all(content_type:)
+      raise NotImplementedError, "#{self.class} does not implement find_all"
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    def initialize
+      @mutex = Concurrent::ReentrantReadWriteLock.new
+    end
+
+    protected
+
+    attr_reader :mutex
+
+    class Query
+      delegate :first, to: :result
+      delegate :map, to: :result
+      delegate :count, to: :result
+
+      def result
+        raise NotImplementedError
+      end
+
+      def apply(filter, context = nil)
+        filter.reduce(self) do |query, (field, value)|
+          if value.is_a?(Hash)
+            k = value.keys.first
+            raise ArgumentError, "Filter not implemented: #{value}" unless query.respond_to?(k)
+            query.public_send(k, field, value[k], context)
+          else
+            query.eq(field.to_s, value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,10 @@ module WCC::Contentful::Store
   class CDNAdapter
     attr_reader :client
 
+    # Intentionally not implementing write methods
+
     def initialize(client)
+      super()
       @client = client
     end
 
@@ -16,29 +19,26 @@ module WCC::Contentful::Store
           client.asset(key, locale: '*')
         end
       entry&.raw
+    rescue WCC::Contentful::SimpleClient::NotFoundError
+      nil
     end
 
-    def find_all
-      raise ArgumentError, 'use find_by content type instead'
+    def find_by(content_type:, filter: nil)
+      # default implementation - can be overridden
+      q = find_all(content_type: content_type)
+      q = q.apply(filter) if filter
+      q.first
     end
 
-    def find_by(content_type:)
+    def find_all(content_type:)
       Query.new(@client, content_type: content_type)
     end
 
-    class Query
+    class Query < Base::Query
       delegate :count, to: :resolve
 
-      def first
-        resolve.items.first
-      end
-
-      def map(&block)
-        resolve.items.map(&block)
-      end
-
       def result
-        raise ArgumentError, 'Not Implemented'
+        resolve.items
       end
 
       def initialize(client, relation)
@@ -48,12 +48,6 @@ module WCC::Contentful::Store
         @relation = relation
       end
 
-      def apply(filter, context = nil)
-        return eq(filter[:field], filter[:eq], context) if filter[:eq]
-
-        raise ArgumentError, "Filter not implemented: #{filter}"
-      end
-
       def eq(field, expected, context = nil)
         locale = context[:locale] if context.present?
         locale ||= 'en-US'

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+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
+    end
+
+    def find(key)
+      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+$/
+        end
+
+      case found.try(:dig, 'sys', 'type')
+      when 'Nil', 'DeletedEntry', 'DeletedAsset'
+        nil
+      else
+        found
+      end
+    end
+
+    # #index is called whenever the sync API comes back with more data.
+    def index(json)
+      id = json.dig('sys', 'id')
+      return unless prev = @cache.read(id)
+
+      if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision'))
+        return prev if next_rev < prev_rev
+      end
+
+      # we also set deletes in the cache - no need to go hit the API when we know
+      # this is a nil object
+      @cache.write(id, json)
+
+      case json.dig('sys', 'type')
+      when 'DeletedEntry', 'DeletedAsset'
+        nil
+      else
+        json
+      end
+    end
+
+    def set(key, value)
+      old = @cache.read(key)
+      @cache.write(key, value)
+      old
+    end
+
+    def delete(key)
+      old = @cache.read(key)
+      @cache.delete(key)
+      old
+    end
+
+    def nil_obj(id)
+      {
+        'sys' => {
+          'id' => id,
+          'type' => 'Nil',
+          'revision' => 1
+        }
+      }
+    end
+  end
+end

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

@@ -1,35 +1,39 @@
 # frozen_string_literal: true
 
 module WCC::Contentful::Store
-  class MemoryStore
+  class MemoryStore < Base
     def initialize
+      super
       @hash = {}
-      @mutex = Mutex.new
     end
 
-    def index(key, value)
+    def set(key, value)
       value = value.deep_dup.freeze
-      @mutex.synchronize do
+      mutex.with_write_lock do
+        old = @hash[key]
         @hash[key] = value
+        old
+      end
+    end
+
+    def delete(key)
+      mutex.with_write_lock do
+        @hash.delete(key)
       end
     end
 
     def keys
-      @mutex.synchronize { @hash.keys }
+      mutex.with_read_lock { @hash.keys }
     end
 
     def find(key)
-      @mutex.synchronize do
+      mutex.with_read_lock do
         @hash[key]
       end
     end
 
-    def find_all
-      Query.new(@mutex.synchronize { @hash.values })
-    end
-
-    def find_by(content_type:)
-      relation = @mutex.synchronize { @hash.values }
+    def find_all(content_type:)
+      relation = mutex.with_read_lock { @hash.values }
 
       relation =
         relation.reject do |v|
@@ -39,11 +43,7 @@ module WCC::Contentful::Store
       Query.new(relation)
     end
 
-    class Query
-      delegate :first, to: :@relation
-      delegate :map, to: :@relation
-      delegate :count, to: :@relation
-
+    class Query < Base::Query
       def result
         @relation.dup
       end
@@ -52,12 +52,6 @@ module WCC::Contentful::Store
         @relation = relation
       end
 
-      def apply(filter, context = nil)
-        return eq(filter[:field], filter[:eq], context) if filter[:eq]
-
-        raise ArgumentError, "Filter not implemented: #{filter}"
-      end
-
       def eq(field, expected, context = nil)
         locale = context[:locale] if context.present?
         locale ||= 'en-US'

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

@@ -4,16 +4,19 @@ gem 'pg', '~> 1.0'
 require 'pg'
 
 module WCC::Contentful::Store
-  class PostgresStore
+  class PostgresStore < Base
     def initialize(connection_options = nil)
+      super()
       connection_options ||= { dbname: 'postgres' }
       @conn = PG.connect(connection_options)
       PostgresStore.ensure_schema(@conn)
     end
 
-    def index(key, value)
-      @conn.exec_prepared('index_entry', [key, value.to_json])
-      true
+    def set(key, 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
 
     def keys
@@ -23,17 +26,19 @@ module WCC::Contentful::Store
       arr
     end
 
-    def find(key)
-      result = @conn.exec_prepared('select_entry', [key])
+    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_all
-      Query.new(@conn)
+    def find(key)
+      result = @conn.exec_prepared('select_entry', [key])
+      return if result.num_tuples == 0
+      JSON.parse(result.getvalue(0, 1))
     end
 
-    def find_by(content_type:)
+    def find_all(content_type:)
       statement = "WHERE data->'sys'->'contentType'->'sys'->>'id' = $1"
       Query.new(
         @conn,
@@ -42,7 +47,7 @@ module WCC::Contentful::Store
       )
     end
 
-    class Query
+    class Query < Base::Query
       def initialize(conn, statement = nil, params = nil)
         @conn = conn
         @statement = statement ||
@@ -50,12 +55,6 @@ module WCC::Contentful::Store
         @params = params || []
       end
 
-      def apply(filter, context = nil)
-        return eq(filter[:field], filter[:eq], context) if filter[:eq]
-
-        raise ArgumentError, "Filter not implemented: #{filter}"
-      end
-
       def eq(field, expected, context = nil)
         locale = context[:locale] if context.present?
         locale ||= 'en-US'
@@ -115,18 +114,32 @@ module WCC::Contentful::Store
     def self.ensure_schema(conn)
       conn.exec(<<~HEREDOC
         CREATE TABLE IF NOT EXISTS contentful_raw (
-          id char(22) PRIMARY KEY,
+          id varchar PRIMARY KEY,
           data jsonb
         );
         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";
+        CREATE FUNCTION "upsert_entry"(_id varchar, _data jsonb) RETURNS jsonb AS $$
+        DECLARE
+          prev jsonb;
+        BEGIN
+          SELECT data FROM contentful_raw WHERE id = _id INTO prev;
+          INSERT INTO contentful_raw (id, data) values (_id, _data)
+            ON CONFLICT (id) DO
+              UPDATE
+              SET data = _data;
+           RETURN prev;
+        END;
+        $$ LANGUAGE 'plpgsql';
 HEREDOC
       )
 
-      conn.prepare('index_entry', 'INSERT INTO contentful_raw (id, data) values ($1, $2) ' \
-        'ON CONFLICT (id) DO UPDATE SET data = $2')
+      conn.prepare('upsert_entry', 'SELECT * FROM upsert_entry($1,$2)')
       conn.prepare('select_entry', 'SELECT * FROM contentful_raw WHERE id = $1')
       conn.prepare('select_ids', 'SELECT id FROM contentful_raw')
+      conn.prepare('delete_by_id', 'DELETE FROM contentful_raw WHERE id = $1 RETURNING *')
     end
   end
 end

data/lib/wcc/contentful/store.rb

@@ -1,8 +1,70 @@
 
 # frozen_string_literal: true
 
+require_relative 'store/base'
 require_relative 'store/memory_store'
+require_relative 'store/lazy_cache_store'
 require_relative 'store/cdn_adapter'
 
 # required dynamically if they select the 'postgres' store option
 # require_relative 'store/postgres_store'
+
+module WCC::Contentful::Store
+  SYNC_STORES = {
+    memory: ->(_config) { WCC::Contentful::Store::MemoryStore.new },
+    postgres: ->(_config) {
+      require_relative 'store/postgres_store'
+      WCC::Contentful::Store::PostgresStore.new(ENV['POSTGRES_CONNECTION'])
+    }
+  }.freeze
+
+  CDN_METHODS = %i[
+    eager_sync
+    lazy_sync
+    direct
+  ].freeze
+
+  Factory =
+    Struct.new(:config, :cdn_method, :content_delivery_params) do
+      def build_sync_store
+        unless respond_to?("build_#{cdn_method}")
+          raise ArgumentError, "Don't know how to build content delivery method #{cdn_method}"
+        end
+
+        public_send("build_#{cdn_method}", config, *content_delivery_params)
+      end
+
+      def validate!
+        unless CDN_METHODS.include?(cdn_method)
+          raise ArgumentError, "Please use one of #{CDN_METHODS} for 'content_delivery'"
+        end
+
+        return unless respond_to?("validate_#{cdn_method}")
+        public_send("validate_#{cdn_method}", config, *content_delivery_params)
+      end
+
+      def build_eager_sync(config, store = nil, *_options)
+        puts "store: #{store}"
+        store = SYNC_STORES[store].call(config) if store.is_a?(Symbol)
+        store || MemoryStore.new
+      end
+
+      def build_lazy_sync(config, *options)
+        WCC::Contentful::Store::LazyCacheStore.new(
+          config.client,
+          cache: ActiveSupport::Cache.lookup_store(*options)
+        )
+      end
+
+      def build_direct(config, *_options)
+        CDNAdapter.new(config.client)
+      end
+
+      def validate_eager_sync(_config, store = nil, *_options)
+        return unless store.is_a?(Symbol)
+
+        return if SYNC_STORES.keys.include?(store)
+        raise ArgumentError, "Please use one of #{SYNC_STORES.keys}"
+      end
+    end
+end

data/lib/wcc/contentful/version.rb

@@ -2,6 +2,6 @@
 
 module WCC
   module Contentful
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end