wcc-contentful 0.4.0.pre.rc → 1.0.0.pre.rc1

data/lib/wcc/contentful/middleware.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Middleware
+end
+
+require_relative './middleware/store'
+# someday: ./middleware/client & ./middleware/model ?

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative '../middleware'
+
+# A Store middleware wraps the Store interface to perform any desired transformations
+# on the Contentful entries coming back from the store.  A Store middleware must
+# implement the Store interface as well as a `store=` attribute writer, which is
+# used to inject the next store or middleware in the chain.
+#
+# The Store interface can be seen on the WCC::Contentful::Store::Base class.  It
+# consists of the `#find, #find_by, #find_all, #set, #delete,` and `#index` methods.
+#
+# Including this concern will define those methods to pass through to the next store.
+# Any of those methods can be overridden on the implementing middleware.
+# It will also expose two overridable methods, `#select?` and `#transform`.  These
+# methods are applied when reading values out of the store, and can be used to
+# apply a filter or transformation to each entry in the store.
+module WCC::Contentful::Middleware::Store
+  extend ActiveSupport::Concern
+  include WCC::Contentful::Store::Interface
+
+  attr_accessor :store
+
+  delegate :index, :index?, to: :store
+
+  class_methods do
+    def call(store, *content_delivery_params, **_)
+      instance = new(*content_delivery_params)
+      instance.store = store
+      instance
+    end
+  end
+
+  def find(id, **options)
+    found = store.find(id, **options)
+    return transform(found) if found && (!has_select? || select?(found))
+  end
+
+  def find_by(options: nil, **args)
+    result = store.find_by(**args.merge(options: options))
+    return unless result && (!has_select? || select?(result))
+
+    result = resolve_includes(result, options[:include]) if options && options[:include]
+    transform(result)
+  end
+
+  def find_all(options: nil, **args)
+    DelegatingQuery.new(
+      store.find_all(**args.merge(options: options)),
+      middleware: self,
+      options: options
+    )
+  end
+
+  def resolve_includes(entry, depth)
+    return entry unless entry && depth && depth > 0
+
+    WCC::Contentful::LinkVisitor.new(entry, :Link, depth: depth).map! do |val|
+      resolve_link(val)
+    end
+  end
+
+  def resolve_link(val)
+    return val unless resolved_link?(val)
+
+    if !has_select? || select?(val)
+      transform(val)
+    else
+      # Pretend it's an unresolved link -
+      # matches the behavior of a store when the link cannot be retrieved
+      WCC::Contentful::Link.new(val.dig('sys', 'id'), val.dig('sys', 'type')).to_h
+    end
+  end
+
+  def resolved_link?(value)
+    value.is_a?(Hash) && value.dig('sys', 'type') == 'Entry'
+  end
+
+  def has_select? # rubocop:disable Naming/PredicateName
+    respond_to?(:select?)
+  end
+
+  # The default version of `#transform` just returns the entry.
+  # Override this with your own implementation.
+  def transform(entry)
+    entry
+  end
+
+  class DelegatingQuery
+    include WCC::Contentful::Store::Query::Interface
+    include Enumerable
+
+    # by default all enumerable methods delegated to the to_enum method
+    delegate(*(Enumerable.instance_methods - Module.instance_methods), to: :to_enum)
+
+    def count
+      if middleware.has_select?
+        raise NameError, "Count cannot be determined because the middleware '#{middleware}'" \
+          " implements the #select? method.  Please use '.to_a.count' to count entries that" \
+          ' pass the #select? method.'
+      end
+
+      # The wrapped query may get count from the "Total" field in the response,
+      # or apply a "COUNT(*)" to the query.
+      wrapped_query.count
+    end
+
+    attr_reader :wrapped_query, :middleware, :options
+
+    def to_enum
+      result = wrapped_query.to_enum
+      result = result.select { |x| middleware.select?(x) } if middleware.has_select?
+
+      if options && options[:include]
+        result = result.map { |x| middleware.resolve_includes(x, options[:include]) }
+      end
+
+      result.map { |x| middleware.transform(x) }
+    end
+
+    def apply(filter, context = nil)
+      self.class.new(
+        wrapped_query.apply(filter, context),
+        middleware: middleware,
+        options: options,
+        **@extra
+      )
+    end
+
+    def apply_operator(operator, field, expected, context = nil)
+      self.class.new(
+        wrapped_query.apply_operator(operator, field, expected, context),
+        middleware: middleware,
+        options: options,
+        **@extra
+      )
+    end
+
+    WCC::Contentful::Store::Query::Interface::OPERATORS.each do |op|
+      # @see #apply_operator
+      define_method(op) do |field, expected, context = nil|
+        self.class.new(
+          wrapped_query.public_send(op, field, expected, context),
+          middleware: middleware,
+          options: options,
+          **@extra
+        )
+      end
+    end
+
+    def initialize(wrapped_query, middleware:, options: nil, **extra)
+      @wrapped_query = wrapped_query
+      @middleware = middleware
+      @options = options
+      @extra = extra
+    end
+  end
+end

data/lib/wcc/contentful/middleware/store/caching_middleware.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Middleware::Store
+  class CachingMiddleware
+    include WCC::Contentful::Middleware::Store
+    # include instrumentation, but not specifically store stack instrumentation
+    include WCC::Contentful::Instrumentation
+
+    attr_accessor :expires_in
+
+    def initialize(cache = nil)
+      @cache = cache || ActiveSupport::Cache::MemoryStore.new
+      @expires_in = nil
+    end
+
+    def find(key, **options)
+      event = 'fresh'
+      found =
+        @cache.fetch(key, expires_in: expires_in) do
+          event = 'miss'
+          # 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.
+          (store.find(key, options) || nil_obj(key)) if key =~ /^\w+$/
+        end
+      _instrument(event, key: key, options: options)
+
+      case found.try(:dig, 'sys', 'type')
+      when 'Nil', 'DeletedEntry', 'DeletedAsset'
+        nil
+      else
+        found
+      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
+
+      store.find_by(content_type: content_type, filter: filter, options: options)
+    end
+
+    delegate :find_all, to: :store
+
+    # #index is called whenever the sync API comes back with more data.
+    def index(json)
+      delegated_result = store.index(json) if store.index?
+      caching_result = _index(json)
+      # _index returns nil if we don't already have it cached - so use the store result.
+      # store result is nil if it doesn't index, so use the caching result if we have it.
+      # They ought to be the same thing if it's cached and the store also indexes.
+      caching_result || delegated_result
+    end
+
+    def index?
+      true
+    end
+
+    private
+
+    LAZILY_CACHEABLE_TYPES = %w[
+      Entry
+      Asset
+      DeletedEntry
+      DeletedAsset
+    ].freeze
+
+    def _index(json)
+      ensure_hash(json)
+      id = json.dig('sys', 'id')
+      type = json.dig('sys', 'type')
+      prev = @cache.read(id)
+      return if prev.nil? && LAZILY_CACHEABLE_TYPES.include?(type)
+
+      if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision'))
+        return prev if next_rev < prev_rev
+      end
+
+      # we also set DeletedEntry objects in the cache - no need to go hit the API when we know
+      # this is a nil object
+      @cache.write(id, json, expires_in: expires_in)
+
+      case type
+      when 'DeletedEntry', 'DeletedAsset'
+        _instrument 'delete', id: id
+        nil
+      else
+        _instrument 'set', id: id
+        json
+      end
+    end
+
+    def nil_obj(id)
+      {
+        'sys' => {
+          'id' => id,
+          'type' => 'Nil',
+          'revision' => 1
+        }
+      }
+    end
+
+    def ensure_hash(val)
+      raise ArgumentError, 'Value must be a Hash' unless val.is_a?(Hash)
+    end
+  end
+end

data/lib/wcc/contentful/model.rb

@@ -54,15 +54,29 @@ class WCC::Contentful::Model
 
   @@registry = {}
 
+  def self.store(preview = false)
+    if preview
+      if preview_store.nil?
+        raise ArgumentError,
+          'You must include a contentful preview token in your WCC::Contentful.configure block'
+      end
+      preview_store
+    else
+      super()
+    end
+  end
+
   # Finds an Entry or Asset by ID in the configured contentful space
   # and returns an initialized instance of the appropriate model type.
   #
   # Makes use of the {WCC::Contentful::Services#store configured store}
   # to access the Contentful CDN.
-  def self.find(id, context = nil)
-    return unless raw = store.find(id)
+  def self.find(id, options: nil)
+    options ||= {}
+    raw = store(options[:preview])
+      .find(id, options.except(*WCC::Contentful::ModelMethods::MODEL_LAYER_CONTEXT_KEYS))
 
-    new_from_raw(raw, context)
+    new_from_raw(raw, options) if raw.present?
   end
 
   # Creates a new initialized instance of the appropriate model type for the
@@ -77,6 +91,8 @@ class WCC::Contentful::Model
   # Accepts a content type ID as a string and returns the Ruby constant
   # stored in the registry that represents this content type.
   def self.resolve_constant(content_type)
+    raise ArgumentError, 'content_type cannot be nil' unless content_type
+
     const = @@registry[content_type]
     return const if const
 
@@ -129,6 +145,24 @@ class WCC::Contentful::Model
     @@registry.dup.freeze
   end
 
+  def self.reload!
+    registry = self.registry
+    registry.each do |(content_type, klass)|
+      const_name = klass.name
+      begin
+        const = Object.const_missing(const_name)
+        register_for_content_type(content_type, klass: const) if const
+      rescue NameError => e
+        msg = "Error when reloading constant #{const_name} - #{e}"
+        if defined?(Rails) && Rails.logger
+          Rails.logger.error msg
+        else
+          puts msg
+        end
+      end
+    end
+  end
+
   # Checks if a content type has already been registered to a class and returns
   # that class.  If nil, the generated WCC::Contentful::Model::{content_type} class
   # will be resolved for this content type.

data/lib/wcc/contentful/model_builder.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative './link'
 require_relative './sys'
 
 module WCC::Contentful

data/lib/wcc/contentful/model_methods.rb

@@ -5,6 +5,15 @@
 #
 # @api Model
 module WCC::Contentful::ModelMethods
+  include WCC::Contentful::Instrumentation
+
+  # The set of options keys that are specific to the Model layer and shouldn't
+  # be passed down to the Store layer.
+  MODEL_LAYER_CONTEXT_KEYS = %i[
+    preview
+    backlinks
+  ].freeze
+
   # Resolves all links in an entry to the specified depth.
   #
   # Each link in the entry is recursively retrieved from the store until the given
@@ -22,7 +31,7 @@ module WCC::Contentful::ModelMethods
   #   handled.  `:raise` causes a {WCC::Contentful::CircularReferenceError} to be raised,
   #   `:ignore` will cause the field to remain unresolved, and any other value (or nil)
   #   will cause the field to point to the previously resolved ruby object for that ID.
-  def resolve(depth: 1, fields: nil, context: {}, **options)
+  def resolve(depth: 1, fields: nil, context: sys.context.to_h, **options)
     raise ArgumentError, "Depth must be > 0 (was #{depth})" unless depth && depth > 0
     return self if resolved?(depth: depth, fields: fields)
 
@@ -32,20 +41,26 @@ module WCC::Contentful::ModelMethods
     typedef = self.class.content_type_definition
     links = fields.select { |f| %i[Asset Link].include?(typedef.fields[f].type) }
 
-    raw_links =
-      links.any? do |field_name|
-        raw_value = raw.dig('fields', field_name, sys.locale)
-        if raw_value&.is_a? Array
-          raw_value.any? { |v| v&.dig('sys', 'type') == 'Link' }
-        elsif raw_value
-          raw_value.dig('sys', 'type') == 'Link'
+    raw_link_ids =
+      links.map { |field_name| raw.dig('fields', field_name, sys.locale) }
+        .flat_map do |raw_value|
+          _try_map(raw_value) { |v| v.dig('sys', 'id') if v.dig('sys', 'type') == 'Link' }
+        end
+    raw_link_ids = raw_link_ids.compact
+    backlinked_ids = (context[:backlinks]&.map { |m| m.id } || [])
+
+    has_unresolved_raw_links = (raw_link_ids - backlinked_ids).any?
+    if has_unresolved_raw_links
+      raw =
+        _instrument 'resolve', id: id, depth: depth, backlinks: backlinked_ids do
+          # use include param to do resolution
+          self.class.store(context[:preview])
+            .find_by(content_type: self.class.content_type,
+                     filter: { 'sys.id' => id },
+                     options: context.except(*MODEL_LAYER_CONTEXT_KEYS).merge!({
+                       include: [depth, 10].min
+                     }))
         end
-      end
-    if raw_links
-      # use include param to do resolution
-      raw = self.class.store.find_by(content_type: self.class.content_type,
-                                     filter: { 'sys.id' => id },
-                                     options: { include: [depth, 10].min })
       unless raw
         raise WCC::Contentful::ResolveError, "Cannot find #{self.class.content_type} with ID #{id}"
       end
@@ -118,6 +133,12 @@ module WCC::Contentful::ModelMethods
 
   delegate :to_json, to: :to_h
 
+  protected
+
+  def _instrumentation_event_prefix
+    '.model.contentful.wcc'
+  end
+
   private
 
   def _resolve_field(field_name, depth = 1, context = {}, options = {})
@@ -147,7 +168,10 @@ module WCC::Contentful::ModelMethods
         # instantiate from already resolved raw entry data.
         m = already_resolved ||
           if raw.dig('sys', 'type') == 'Link'
-            WCC::Contentful::Model.find(id, new_context)
+            _instrument 'resolve',
+              id: self.id, depth: depth, backlinks: context[:backlinks]&.map(&:id) do
+              WCC::Contentful::Model.find(id, options: new_context)
+            end
           else
             WCC::Contentful::Model.new_from_raw(raw, new_context)
           end
@@ -158,6 +182,7 @@ module WCC::Contentful::ModelMethods
 
     begin
       val = _try_map(val) { |v| load.call(v) }
+      val = val.compact if val.is_a? Array
 
       instance_variable_set(var_name + '_resolved', val)
     rescue WCC::Contentful::CircularReferenceError