wcc-contentful 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f99e076627c9facfff117f6d9df87dcf593d8a07bb6d3351b159172207aff81a
-  data.tar.gz: 463c6b34cbf4a5718736e04365a9705795fd1f3435167cc1028d5c217596fb34
+  metadata.gz: f05ea585d54f7ca83c96e018021f88776ebb148cc40b7d719d6199b3a3cd9d0c
+  data.tar.gz: 0da490d12beb9938ec51c0ac40e140420966667b72afebc5c9895cf197308ea8
 SHA512:
-  metadata.gz: 4be52c0f698f59b61f91d547ae7a2588b07bc9d184cd09a78730f7a09b290d005770b4f1ab3306d7e9cbc9ca0e5a20c7dc3c63fa39417a7c3219bf4c28ecd8a8
-  data.tar.gz: a1e93027a2a81655f9dbe82ee54c4f77061ef757c2dee9e3fe12369ce9f8d698fd01a7ab9a2510244273f567dbbdb05084eeb3b333abcafce9ccb05c6e62c4bc
+  metadata.gz: 979360a35356b041dbe0f8bbd4f0e5bfcaf91909ccc567322ceef8493de25300ea09a081e755142fe23bf9cfd5ea86ca7f919d3218d5dec44a98bcab5921af7d
+  data.tar.gz: 9e5f29e70fdcbccffd72aeb8b896e3518d2236cd699704289e8a3fdf1392201dc49671bab0eb83948e79ee079366de90b46add4ce2027e065db2da28b2be4e85

data/app/jobs/wcc/contentful/webhook_enable_job.rb

@@ -11,20 +11,19 @@ module WCC::Contentful
       args = default_configuration.merge!(args)
 
       client = WCC::Contentful::SimpleClient::Management.new(
-        args
+        **args
       )
-      enable_webhook(client, args.slice(:app_url, :webhook_username, :webhook_password))
+      enable_webhook(client, args.slice(:receive_url, :webhook_username, :webhook_password))
     end
 
-    def enable_webhook(client, app_url:, webhook_username: nil, webhook_password: nil)
-      expected_url = URI.join(app_url, 'webhook/receive').to_s
-      webhook = client.webhook_definitions.items.find { |w| w['url'] == expected_url }
+    def enable_webhook(client, receive_url:, webhook_username: nil, webhook_password: nil)
+      webhook = client.webhook_definitions.items.find { |w| w['url'] == receive_url }
       logger.debug "existing webhook: #{webhook.inspect}" if webhook
       return if webhook
 
       body = {
         'name' => 'WCC::Contentful webhook',
-        'url' => expected_url,
+        'url' => receive_url,
         'topics' => [
           '*.publish',
           '*.unpublish'
@@ -50,13 +49,14 @@ module WCC::Contentful
 
       {
         management_token: config.management_token,
-        app_url: config.app_url,
         space: config.space,
         environment: config.environment,
         default_locale: config.default_locale,
         connection: config.connection,
         webhook_username: config.webhook_username,
-        webhook_password: config.webhook_password
+        webhook_password: config.webhook_password,
+
+        receive_url: URI.join(config.app_url, 'webhook/receive').to_s
       }
     end
 

data/lib/wcc/contentful/active_record_shim.rb

@@ -64,13 +64,13 @@ module WCC::Contentful::ActiveRecordShim
         }
       }
 
-      find_all(filter).each_slice(batch_size, &block)
+      find_all(**filter).each_slice(batch_size, &block)
     end
 
     def where(**conditions)
       # TODO: return a Query object that implements more of the ActiveRecord query interface
       # https://guides.rubyonrails.org/active_record_querying.html#conditions
-      find_all(conditions)
+      find_all(**conditions)
     end
   end
 end

data/lib/wcc/contentful/content_type_indexer.rb

@@ -137,6 +137,8 @@ module WCC::Contentful
         :Json
       when 'Location'
         :Coordinates
+      when 'RichText'
+        :RichText
       when 'Array'
         find_field_type(field.try(:items) || field['items'])
       when 'Link'

data/lib/wcc/contentful/event.rb

@@ -7,10 +7,10 @@ module WCC::Contentful::Event
 
   # Creates an Event out of a raw value received by a webhook or given from
   # the Contentful Sync API.
-  def self.from_raw(raw, context = nil)
+  def self.from_raw(raw, context = nil, source: nil)
     const = Registry.instance.get(raw.dig('sys', 'type'))
 
-    const.new(raw, context)
+    const.new(raw, context, source: source)
   end
 
   class Registry
@@ -134,12 +134,6 @@ class WCC::Contentful::Event::SyncComplete
   include WCC::Contentful::Event
 
   def initialize(items, context = nil, source: nil)
-    items =
-      items.map do |item|
-        next item if item.is_a? WCC::Contentful::Event
-
-        WCC::Contentful::Event.from_raw(item, context, source: source)
-      end
     @items = items.freeze
     @source = source
     @sys = WCC::Contentful::Sys.new(

data/lib/wcc/contentful/indexed_representation.rb

@@ -103,6 +103,7 @@ module WCC::Contentful
         Boolean
         Json
         Coordinates
+        RichText
         Link
         Asset
       ].freeze

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

@@ -20,7 +20,7 @@ module WCC::Contentful::Middleware::Store
           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+$/
+          (store.find(key, **options) || nil_obj(key)) if key =~ /^\w+$/
         end
       _instrument(event, key: key, options: options)
 

data/lib/wcc/contentful/model.rb

@@ -41,10 +41,6 @@ require_relative './model_api'
 class WCC::Contentful::Model
   include WCC::Contentful::ModelAPI
 
-  # The Model base class maintains a registry which is best expressed as a
-  # class var.
-  # rubocop:disable Style/ClassVars
-
   class << self
     def const_missing(name)
       type = WCC::Contentful::Helpers.content_type_from_constant(name)
@@ -53,5 +49,3 @@ class WCC::Contentful::Model
     end
   end
 end
-
-# rubocop:enable Style/ClassVars

data/lib/wcc/contentful/model_api.rb

@@ -13,9 +13,8 @@ module WCC::Contentful::ModelAPI
       services.instrumentation
     end
 
-    # We use a class var here because this is a global registry for all subclasses
-    # of this namespace
-    @@registry = {} # rubocop:disable Style/ClassVars
+    # Set the registry at the top of the namespace
+    @registry = {}
   end
 
   class_methods do
@@ -69,7 +68,7 @@ module WCC::Contentful::ModelAPI
       store = options[:preview] ? services.preview_store : services.store
       raw =
         _instrumentation.instrument 'find.model.contentful.wcc', id: id, options: options do
-          store.find(id, options.except(*WCC::Contentful::ModelMethods::MODEL_LAYER_CONTEXT_KEYS))
+          store.find(id, **options.except(*WCC::Contentful::ModelMethods::MODEL_LAYER_CONTEXT_KEYS))
         end
 
       new_from_raw(raw, options) if raw.present?
@@ -89,7 +88,7 @@ module WCC::Contentful::ModelAPI
     def resolve_constant(content_type)
       raise ArgumentError, 'content_type cannot be nil' unless content_type
 
-      const = @@registry[content_type]
+      const = _registry[content_type]
       return const if const
 
       const_name = WCC::Contentful::Helpers.constant_from_content_type(content_type).to_s
@@ -143,14 +142,14 @@ module WCC::Contentful::ModelAPI
 
       content_type ||= WCC::Contentful::Helpers.content_type_from_constant(klass)
 
-      @@registry[content_type] = klass
+      _registry[content_type] = klass
     end
 
     # Returns the current registry of content type names to constants.
     def registry
-      return {} unless @@registry
+      return {} unless _registry
 
-      @@registry.dup.freeze
+      _registry.dup.freeze
     end
 
     def reload!
@@ -176,7 +175,15 @@ module WCC::Contentful::ModelAPI
     # that class.  If nil, the generated WCC::Contentful::Model::{content_type} class
     # will be resolved for this content type.
     def registered?(content_type)
-      @@registry[content_type]
+      _registry[content_type]
+    end
+
+    protected
+
+    def _registry
+      # If calling register_for_content_type in a subclass, look up the superclass
+      # chain until we get to the model namespace which defines the registry
+      @registry || superclass._registry
     end
   end
 end

data/lib/wcc/contentful/model_builder.rb

@@ -2,6 +2,7 @@
 
 require_relative './link'
 require_relative './sys'
+require_relative './rich_text'
 
 module WCC::Contentful
   class ModelBuilder
@@ -95,6 +96,8 @@ module WCC::Contentful
                 #
                 # when :DateTime
                 #   raw_value = Time.parse(raw_value).localtime
+                when :RichText
+                  raw_value = WCC::Contentful::RichText.tokenize(raw_value)
                 when :Int
                   raw_value = Integer(raw_value)
                 when :Float

data/lib/wcc/contentful/model_singleton_methods.rb

@@ -16,7 +16,7 @@ module WCC::Contentful::ModelSingletonMethods
     raw =
       _instrumentation.instrument 'find.model.contentful.wcc',
         content_type: content_type, id: id, options: options do
-        store.find(id, { hint: type }.merge!(options.except(:preview)))
+        store.find(id, **{ hint: type }.merge!(options.except(:preview)))
       end
     new(raw, options) if raw.present?
   end
@@ -69,9 +69,9 @@ module WCC::Contentful::ModelSingletonMethods
   def inherited(subclass)
     # If another different class is already registered for this content type,
     # don't auto-register this one.
-    return if WCC::Contentful::Model.registered?(content_type)
+    return if model_namespace.registered?(content_type)
 
-    WCC::Contentful::Model.register_for_content_type(content_type, klass: subclass)
+    model_namespace.register_for_content_type(content_type, klass: subclass)
   end
 
   class ModelQuery

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

@@ -0,0 +1,62 @@
+# 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)
+        unless raw['nodeType'] == node_type
+          raise ArgumentError, "Expected '#{node_type}', got '#{raw['nodeType']}'"
+        end
+
+        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/simple_client/response.rb

@@ -49,7 +49,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 +57,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 +76,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)
@@ -118,11 +108,6 @@ class WCC::Contentful::SimpleClient
         raw.dig('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 +129,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 +145,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 +166,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/store/cdn_adapter.rb

@@ -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)
@@ -105,6 +109,11 @@ module WCC::Contentful::Store
 
       def apply_operator(operator, field, expected, context = nil)
         op = operator == :eq ? nil : operator
+        if expected.is_a?(Array)
+          expected = expected.join(',')
+          op = :in if op.nil?
+        end
+
         param = parameter(field, operator: op, context: context, locale: true)
 
         self.class.new(
@@ -155,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/memory_store.rb

@@ -38,7 +38,13 @@ module WCC::Contentful::Store
       end
     end
 
+    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"
+      end
+
       relation = mutex.with_read_lock { @hash.values }
 
       # relation is an enumerable that we apply conditions to in the form of
@@ -56,21 +62,49 @@ module WCC::Contentful::Store
       # For each condition, we apply a new Enumerable#select with a block that
       # enforces the condition.
       query.conditions.reduce(relation) do |memo, condition|
-        memo.select do |entry|
-          # Our naiive implementation only supports equality operator
-          raise ArgumentError, "Operator #{condition.op} not supported" unless condition.op == :eq
+        __send__("apply_#{condition.op}", memo, condition)
+      end
+    end
 
-          # The condition's path tells us where to find the value in the JSON object
-          val = entry.dig(*condition.path)
+    private
 
-          # 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
-        end
+    def apply_eq(memo, condition)
+      memo.select { |entry| eq?(entry, condition) }
+    end
+
+    def apply_ne(memo, condition)
+      memo.reject { |entry| eq?(entry, condition) }
+    end
+
+    def eq?(entry, condition)
+      # The condition's path tells us where to find the value in the JSON object
+      val = entry.dig(*condition.path)
+
+      # 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
+    end
+
+    def apply_in(memo, condition)
+      memo.select { |entry| in?(entry, condition) }
+    end
+
+    def apply_nin(memo, condition)
+      memo.reject { |entry| in?(entry, condition) }
+    end
+
+    def in?(entry, condition)
+      val = entry.dig(*condition.path)
+
+      if val.is_a? Array
+        # TODO: detect if in ruby 3.1 and use val.intersect?(condition.expected)
+        val.any? { |item| condition.expected.include?(item) }
+      else
+        condition.expected.include?(val)
       end
     end
   end