wcc-contentful 0.4.0.pre.alpha → 1.0.0.pre.rc3

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

@@ -4,10 +4,10 @@
 class WCC::Contentful::SimpleClient::Management < WCC::Contentful::SimpleClient
   def initialize(space:, management_token:, **options)
     super(
-      api_url: options[:api_url] || 'https://api.contentful.com',
+      **options,
+      api_url: options[:management_api_url] || 'https://api.contentful.com',
       space: space,
       access_token: management_token,
-      **options
     )
 
     @post_adapter = @adapter if @adapter.respond_to?(:post)
@@ -19,12 +19,34 @@ class WCC::Contentful::SimpleClient::Management < WCC::Contentful::SimpleClient
   end
 
   def content_types(**query)
-    resp = get('content_types', query)
+    resp =
+      _instrument 'content_types', query: query do
+        get('content_types', query)
+      end
+    resp.assert_ok!
+  end
+
+  def content_type(key, query = {})
+    resp =
+      _instrument 'content_types', content_type: key, query: query do
+        get("content_types/#{key}", query)
+      end
+    resp.assert_ok!
+  end
+
+  def editor_interface(content_type_id, query = {})
+    resp =
+      _instrument 'editor_interfaces', content_type: content_type_id, query: query do
+        get("content_types/#{content_type_id}/editor_interface", query)
+      end
     resp.assert_ok!
   end
 
   def webhook_definitions(**query)
-    resp = get("/spaces/#{space}/webhook_definitions", query)
+    resp =
+      _instrument 'webhook_definitions', query: query do
+        get("/spaces/#{space}/webhook_definitions", query)
+      end
     resp.assert_ok!
   end
 
@@ -51,30 +73,41 @@ class WCC::Contentful::SimpleClient::Management < WCC::Contentful::SimpleClient
   #   ]
   # }
   def post_webhook_definition(webhook)
-    resp = post("/spaces/#{space}/webhook_definitions", webhook)
+    resp =
+      _instrument 'post.webhook_definitions' do
+        post("/spaces/#{space}/webhook_definitions", webhook)
+      end
     resp.assert_ok!
   end
 
   def post(path, body)
     url = URI.join(@api_url, path)
 
+    resp =
+      _instrument 'post_http', url: url do
+        post_http(url, body)
+      end
+
     Response.new(self,
       { url: url, body: body },
-      post_http(url, body))
+      resp)
   end
 
   private
 
-  def post_http(url, body, headers = {}, proxy = {})
+  def post_http(url, body, headers = {})
     headers = {
       Authorization: "Bearer #{@access_token}",
       'Content-Type' => 'application/vnd.contentful.management.v1+json'
     }.merge(headers || {})
 
-    resp = @post_adapter.post(url, body, headers, proxy)
+    body = body.to_json unless body.is_a? String
+    resp = @post_adapter.post(url, body, headers)
 
-    if [301, 302, 307].include?(resp.code) && !@options[:no_follow_redirects]
-      resp = get_http(resp.headers['location'], nil, headers, proxy)
+    if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp = get_http(resp.headers['location'], nil, headers)
+    elsif resp.status == 308 && !@options[:no_follow_redirects]
+      resp = post_http(resp.headers['location'], body, headers)
     end
     resp
   end

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

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
+require_relative '../instrumentation'
+
 class WCC::Contentful::SimpleClient
   class Response
+    include ::WCC::Contentful::Instrumentation
+
     attr_reader :raw_response
     attr_reader :client
     attr_reader :request
 
-    delegate :code, to: :raw_response
+    delegate :status, to: :raw_response
+    alias_method :code, :status
     delegate :headers, to: :raw_response
 
     def body
@@ -19,25 +24,41 @@ class WCC::Contentful::SimpleClient
     alias_method :to_json, :raw
 
     def error_message
-      raw.dig('message') || "#{code}: #{raw_response.message}"
+      parsed_message =
+        begin
+          raw.dig('message')
+        rescue JSON::ParserError
+          nil
+        end
+      parsed_message || "#{code}: #{raw_response.body}"
+    end
+
+    def skip
+      raw['skip']
+    end
+
+    def total
+      raw['total']
     end
 
     def next_page?
       return unless raw.key? 'items'
 
-      raw['items'].length + raw['skip'] < raw['total']
+      page_items.length + skip < total
     end
 
     def next_page
       return unless next_page?
-
-      @next_page ||= @client.get(
-        @request[:url],
-        (@request[:query] || {}).merge({
-          skip: raw['items'].length + raw['skip']
-        })
-      )
-      @next_page.assert_ok!
+      return @next_page if @next_page
+
+      query = (@request[:query] || {}).merge({
+        skip: page_items.length + skip
+      })
+      np =
+        _instrument 'page', url: @request[:url], query: query do
+          @client.get(@request[:url], query)
+        end
+      @next_page = np.assert_ok!
     end
 
     def initialize(client, request, raw_response)
@@ -48,13 +69,13 @@ class WCC::Contentful::SimpleClient
     end
 
     def assert_ok!
-      return self if code >= 200 && code < 300
+      return self if status >= 200 && status < 300
 
-      raise ApiError[code], self
+      raise ApiError[status], self
     end
 
     def each_page(&block)
-      raise ArgumentError, 'Not a collection response' unless raw['items']
+      raise ArgumentError, 'Not a collection response' unless page_items
 
       ret =
         Enumerator.new do |y|
@@ -75,19 +96,21 @@ class WCC::Contentful::SimpleClient
     end
 
     def items
-      each_page.flat_map do |page|
-        page.raw['items']
-      end
+      each_page.flat_map(&:page_items)
+    end
+
+    def page_items
+      raw['items']
     end
 
     def count
-      raw['total']
+      total
     end
 
     def first
-      raise ArgumentError, 'Not a collection response' unless raw['items']
+      raise ArgumentError, 'Not a collection response' unless page_items
 
-      raw['items'].first
+      page_items.first
     end
 
     def includes
@@ -115,7 +138,13 @@ class WCC::Contentful::SimpleClient
     def next_page
       return unless next_page?
 
-      @next_page ||= SyncResponse.new(@client.get(raw['nextPageUrl']))
+      url = raw['nextPageUrl']
+      next_page =
+        _instrument 'page', url: url do
+          @client.get(url)
+        end
+
+      @next_page ||= SyncResponse.new(next_page)
       @next_page.assert_ok!
     end
 
@@ -129,7 +158,7 @@ class WCC::Contentful::SimpleClient
     end
 
     def each_page
-      raise ArgumentError, 'Not a collection response' unless raw['items']
+      raise ArgumentError, 'Not a collection response' unless page_items
 
       ret =
         Enumerator.new do |y|
@@ -168,6 +197,10 @@ class WCC::Contentful::SimpleClient
       case code
       when 404
         NotFoundError
+      when 401
+        UnauthorizedError
+      when 429
+        RateLimitError
       else
         ApiError
       end
@@ -181,4 +214,10 @@ class WCC::Contentful::SimpleClient
 
   class NotFoundError < ApiError
   end
+
+  class UnauthorizedError < ApiError
+  end
+
+  class RateLimitError < ApiError
+  end
 end

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

@@ -3,15 +3,15 @@
 gem 'typhoeus'
 require 'typhoeus'
 
-class TyphoeusAdapter
-  def call(url, query, headers = {}, proxy = {})
-    raise NotImplementedError, 'Proxying Not Yet Implemented' if proxy[:host]
-
-    TyphoeusAdapter::Response.new(
+class WCC::Contentful::SimpleClient::TyphoeusAdapter
+  def get(url, params = {}, headers = {})
+    req = OpenStruct.new(params: params, headers: headers)
+    yield req if block_given?
+    Response.new(
       Typhoeus.get(
         url,
-        params: query,
-        headers: headers
+        params: req.params,
+        headers: req.headers
       )
     )
   end
@@ -19,7 +19,7 @@ class TyphoeusAdapter
   def post(url, body, headers = {}, proxy = {})
     raise NotImplementedError, 'Proxying Not Yet Implemented' if proxy[:host]
 
-    TyphoeusAdapter::Response.new(
+    Response.new(
       Typhoeus.post(
         url,
         body: body.to_json,
@@ -28,15 +28,15 @@ class TyphoeusAdapter
     )
   end
 
-  Response =
-    Struct.new(:raw) do
-      delegate :body, to: :raw
-      delegate :to_s, to: :body
-      delegate :code, to: :raw
-      delegate :headers, to: :raw
+  class Response < SimpleDelegator
+    delegate :to_s, to: :body
 
-      def status
-        raw.code
-      end
+    def raw
+      __getobj__
     end
+
+    def status
+      code
+    end
+  end
 end

data/lib/wcc/contentful/store.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'store/base'
-require_relative 'store/memory_store'
-require_relative 'store/cdn_adapter'
-require_relative 'store/lazy_cache_store'
+require_relative 'store/factory'
 
 # The "Store" is the middle layer in the WCC::Contentful gem.  It exposes an API
 # that implements the configured content delivery strategy.
@@ -18,84 +15,28 @@ require_relative 'store/lazy_cache_store'
 #
 # lazy_sync:: Uses the Contentful CDN in combination with an ActiveSupport::Cache
 #             implementation in order to respond with the cached data where possible,
-#             saving your CDN quota.  The cache is kept up-to-date via the Sync API
-#             and the WCC::Contentful::DelayedSyncJob.  It is correct, but not complete.
+#             saving your CDN quota.  The cache is kept up-to-date via the Sync Engine
+#             and the WCC::Contentful::SyncEngine::Job.  It is correct, but not complete.
 #
 # eager_sync:: Uses one of the full store implementations to store the entirety
 #              of the Contentful space locally.  All queries are run against this
-#              local copy, which is kept up to date via the Sync API and the
-#              WCC::Contentful::DelayedSyncJob.  The local store is correct and complete.
+#              local copy, which is kept up to date via the Sync Engine and the
+#              WCC::Contentful::SyncEngine::Job.  The local store is correct and complete.
 #
 # The currently configured store is available on WCC::Contentful::Services.instance.store
 module WCC::Contentful::Store
   SYNC_STORES = {
-    memory: ->(_config) { WCC::Contentful::Store::MemoryStore.new },
+    memory: ->(_config, *_options) { WCC::Contentful::Store::MemoryStore.new },
     postgres: ->(config, *options) {
       require_relative 'store/postgres_store'
       WCC::Contentful::Store::PostgresStore.new(config, *options)
     }
   }.freeze
 
-  CDN_METHODS = %i[
+  PRESETS = %i[
     eager_sync
     lazy_sync
     direct
     custom
   ].freeze
-
-  Factory =
-    Struct.new(:config, :services, :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} instead of #{cdn_method}"
-        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)
-        store = SYNC_STORES[store].call(config, *options) if store.is_a?(Symbol)
-        store || MemoryStore.new
-      end
-
-      def build_lazy_sync(_config, *options)
-        WCC::Contentful::Store::LazyCacheStore.new(
-          services.client,
-          cache: ActiveSupport::Cache.lookup_store(*options)
-        )
-      end
-
-      def build_direct(_config, *options)
-        if options.find { |array| array[:preview] == true }
-          CDNAdapter.new(services.preview_client)
-        else
-          CDNAdapter.new(services.client)
-        end
-      end
-
-      def build_custom(config, *options)
-        store = config.store
-        return store unless store&.respond_to?(:new)
-
-        store.new(config, options)
-      end
-
-      def validate_eager_sync(_config, store = nil, *_options)
-        return unless store.is_a?(Symbol)
-
-        return if SYNC_STORES.key?(store)
-
-        raise ArgumentError, "Please use one of #{SYNC_STORES.keys}"
-      end
-    end
 end

data/lib/wcc/contentful/store/README.md

@@ -0,0 +1,85 @@
+# Store API
+
+The Store layer is used by the Model API to access Contentful data in a raw form.
+The Store layer returns entries as hashes parsed from JSON, conforming to the
+object structure returned from the Contentful CDN.
+
+## Public Interface
+
+See WCC::Contentful::Store::Interface in wcc/contentful/store/interface.rb
+
+This is the interface consumed by higher layers, such as the Model and GraphQL
+APIs.  It implements the following methods:
+
+* `index?` - Returns boolean true if the SyncEngine should call the store's `index(json)`
+  method with the results of a Sync.
+* `index(json)` - Updates the store with the latest data.  The JSON can be an Entry,
+  Asset, DeletedEntry, or DeletedAsset.
+* `find(id)` - Finds an entry or asset by it's ID.
+* `find_all(content_type:, options: nil)` - Returns a query object that can be
+  enumerated to lazily iterate over all values of a content type.  Query conditions
+  can be applied on the query object before it is enumerated to restrict the result
+  set.
+* `find_by(content_type:, filter: nil, options: nil)` - Returns the first entry 
+  of the given content type which matches the filter.  
+  Note: assets have the special content
+    type of `Asset` (capital A)
+
+## Implementing your own store
+
+The most straightforward way to implement a store is to include the
+WCC::Contentful::Store::Interface module and then override all the defined
+methods.  The easiest way however, is to inherit from WCC::Contentful::Store::Base
+and override the `set`, `delete`, `find`, and `execute` methods.
+
+Let's take a look at the MemoryStore for a simplistic example.  The MemoryStore
+stores entries in a simple Ruby hash keyed by entry ID.  `set` is simply
+assigning to the key in the hash and returning the old value. `delete` and `find`
+are likewise simple.  The only complex method is `execute`, because it powers the
+`find_by` and `find_all` query methods.
+
+The query passed in to `execute` is an instance of WCC::Contentful::Store::Query.
+This object contains a set of WCC::Contentful::Store::Query::Condition structs.
+Each struct is a tuple of `path`, `op`, and `expected`.  `op` is one of
+WCC::Contentful::Store::Query::Interface::OPERATORS, `path` is an array of fields
+pointing to a value in the JSON representation of an entry, and `expected` is the
+expected value that should be compared to the value selected by `path`.
+
+Since the MemoryStore only implements the equality operator, it simply digs
+out the value at the given path using `val = entry.dig(*condition.path)`
+and compares it using Contentful's definition of equality:
+```rb
+# For arrays, equality is defined as does the array include the expected value.
+# See https://www.contentful.com/developers/docs/references/content-delivery-api/#/reference/search-parameters/array-equality-inequality
+if val.is_a? Array
+  val.include?(condition.expected)
+else
+  val == condition.expected
+end
+```
+
+### RSpec shared examples
+
+To ensure you have implemented all the appropriate behavior, there
+are a set of rspec shared examples in wcc/contentful/store/rspec_examples.rb which
+you can include in your specs for your store implementation.  Let's look at
+spec/wcc/contentful/store/memory_store_spec.rb to see how it's used:
+
+```rb
+require 'wcc/contentful/store/rspec_examples'
+
+RSpec.describe WCC::Contentful::Store::MemoryStore do
+  subject { WCC::Contentful::Store::MemoryStore.new }
+
+  it_behaves_like 'contentful store', {
+    # memory store does not support JOINs like `Player.find_by(team: { slug: 'dallas-cowboys' })
+    nested_queries: false,
+    # Memory store supports resolving includes, but it does so in the most naiive
+    # way possible (by recursing down the entry's links and calling #find on every one)
+    include_param: 0
+  }
+```
+
+The hash passed to the shared examples describes the features that the store
+supports.  Any key not provided causes the specs to be given the 'pending'
+attribute.  You can disable a set of specs by providing `false` for that key.