wcc-contentful 0.3.0 → 1.0.0.pre.rc2

data/lib/wcc/contentful/sync_engine.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'wcc/contentful/event'
+require 'wisper'
+
+begin
+  gem 'activejob'
+  require 'active_job'
+rescue Gem::LoadError # rubocop:disable Lint/HandleExceptions
+  # suppress
+end
+
+module WCC::Contentful
+  # The SyncEngine is used to keep the currently configured store up to date
+  # using the Sync API.  It is available on the WCC::Contentful::Services instance,
+  # and the application is responsible to periodically call #next in order to hit
+  # the sync API and update the store.
+  #
+  # If you have mounted the WCC::Contentful::Engine, AND the configured store is
+  # one that can be synced (i.e. it responds to `:index`), then
+  # the WCC::Contentful::WebhookController will call #next automatically anytime
+  # a webhook is received.  Otherwise you should hook up to the Webhook events
+  # and call the sync engine via your initializer:
+  #     WCC::Contentful::Events.subscribe(proc do |event|
+  #       WCC::Contentful::Services.instance.sync_engine.next(up_to: event.dig('sys', 'id'))
+  #     end, with: :call)
+  class SyncEngine
+    include ::Wisper::Publisher
+
+    def state
+      (@state&.dup || token_wrapper_factory(nil)).freeze
+    end
+
+    attr_reader :store
+    attr_reader :client
+
+    def should_sync?
+      store&.index?
+    end
+
+    def initialize(state: nil, store: nil, client: nil, key: nil)
+      @state_key = key || "sync:#{object_id}"
+      @client = client || WCC::Contentful::Services.instance.client
+      @mutex = Mutex.new
+
+      if store
+        unless %i[index index? find].all? { |m| store.respond_to?(m) }
+          raise ArgumentError, ':store param must implement the Store interface'
+        end
+
+        @store = store
+        @state = read_state if should_sync?
+      end
+      if state
+        @state = token_wrapper_factory(state)
+        raise ArgumentError, ':state param must be a String or Hash' unless @state.is_a? Hash
+        unless @state.dig('sys', 'type') == 'token'
+          raise ArgumentError, ':state param must be of sys.type = "token"'
+        end
+      end
+      raise ArgumentError, 'either :state or :store must be provided' unless @state || @store
+    end
+
+    # Gets the next increment of data from the Sync API.
+    # If the configured store responds to `:index`, that will be called with each
+    # item in the Sync response to update the store.
+    # If a block is passed, that block will be evaluated with each item in the
+    # response.
+    # @param [String] up_to_id An ID to look for in the response.  The method returns
+    #   true if the ID was found or no up_to_id was given, false if the ID did not come back.
+    # @return [Array] A `[Boolean, Integer]` tuple where the first value is whether the ID was found,
+    #   and the second value is the number of items returned.
+    def next(up_to_id: nil)
+      id_found = up_to_id.nil?
+      all_events = []
+
+      @mutex.synchronize do
+        @state ||= read_state || token_wrapper_factory(nil)
+        next_sync_token = @state['token']
+
+        sync_resp = client.sync(sync_token: next_sync_token)
+        sync_resp.items.each do |item|
+          id = item.dig('sys', 'id')
+          id_found ||= id == up_to_id
+
+          store.index(item) if store&.index?
+          event = WCC::Contentful::Event.from_raw(item, source: self)
+          yield(event) if block_given?
+          emit_event(event)
+          all_events << event
+        end
+
+        @state = @state.merge('token' => sync_resp.next_sync_token)
+        write_state
+      end
+
+      emit_sync_complete(all_events)
+
+      [id_found, all_events.length]
+    end
+
+    def emit_event(event)
+      type = event.dig('sys', 'type')
+      raise ArgumentError, "Unknown event type #{event}" unless type.present?
+
+      broadcast(type, event)
+    end
+
+    def emit_sync_complete(events)
+      event = WCC::Contentful::Event::SyncComplete.new(events, source: self)
+      broadcast('SyncComplete', event)
+    end
+
+    private
+
+    def read_state
+      return unless found = store&.find(@state_key)
+
+      # backwards compat - migrate existing state
+      token_wrapper_factory(found)
+    end
+
+    def write_state
+      store.index(@state) if store&.index?
+    end
+
+    def token_wrapper_factory(state)
+      state = { 'token' => state } unless state.is_a? Hash
+
+      state.merge!('sys' => { 'id' => @state_key, 'type' => 'token' }) unless state['sys']
+      state
+    end
+
+    # Define the job only if rails is loaded
+    if defined?(ActiveJob)
+      # This job uses the Contentful Sync API to update the configured store with
+      # the latest data from Contentful.
+      class Job < ActiveJob::Base
+        include WCC::Contentful::ServiceAccessors
+
+        self.queue_adapter = :async
+        queue_as :default
+
+        def perform(event = nil)
+          return unless sync_engine&.should_sync?
+
+          up_to_id = nil
+          up_to_id = event[:up_to_id] || event.dig('sys', 'id') if event
+          sync!(up_to_id: up_to_id)
+        end
+
+        # Calls the Contentful Sync API and updates the configured store with the returned
+        # data.
+        #
+        # @param [String] up_to_id
+        #  An ID that we know has changed and should come back from the sync.
+        #  If we don't find this ID in the sync data, then drop a job to try
+        #  the sync again after a few minutes.
+        #
+        def sync!(up_to_id: nil)
+          id_found, count = sync_engine.next(up_to_id: up_to_id)
+
+          next_sync_token = sync_engine.state['token']
+
+          logger.info "Synced #{count} entries.  Next sync token:\n  #{next_sync_token}"
+          logger.info "Should enqueue again? [#{!id_found}]"
+          # Passing nil to only enqueue the job 1 more time
+          sync_later!(up_to_id: nil) unless id_found
+          next_sync_token
+        end
+
+        # Drops an ActiveJob job to invoke WCC::Contentful.sync! after a given amount
+        # of time.
+        def sync_later!(up_to_id: nil, wait: 10.minutes)
+          self.class.set(wait: wait)
+            .perform_later(up_to_id: up_to_id)
+        end
+      end
+    end
+  end
+end

data/lib/wcc/contentful/test.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Test
+end
+
+require_relative 'test/double'
+require_relative 'test/factory'

data/lib/wcc/contentful/test/attributes.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Test::Attributes
+  DEFAULTS = {
+    String: 'test',
+    Int: 0,
+    Float: 0.0,
+    DateTime: Time.at(0).to_s,
+    Boolean: false,
+    Json: ->(_f) { {} },
+    Coordinates: ->(_f) { {} },
+    Asset: ->(f) {
+             WCC::Contentful::Link.new(
+               "fake-#{f.name}-#{SecureRandom.urlsafe_base64[1..6]}",
+               :Asset
+             ).raw
+           },
+    Link: ->(f) {
+            WCC::Contentful::Link.new(
+              "fake-#{f.name}-#{SecureRandom.urlsafe_base64[1..6]}",
+              :Link
+            ).raw
+          }
+  }.freeze
+
+  class << self
+    def [](key)
+      DEFAULTS[key]
+    end
+
+    ##
+    # Get a hash of default values for all attributes unique to the given Contentful model.
+    def defaults(const)
+      unless const < WCC::Contentful::Model
+        raise ArgumentError, "#{const} is not a subclass of WCC::Contentful::Model"
+      end
+
+      const.content_type_definition.fields.each_with_object({}) do |(name, f), h|
+        h[name.to_sym] = h[name.underscore.to_sym] = default_value(f)
+      end
+    end
+
+    ##
+    # Gets the default value for a contentful IndexedRepresentation::Field.
+    # This comes from the 'content_type_definition' of a contentful model class.
+    def default_value(field)
+      return [] if field.array
+      return unless field.required
+
+      val = DEFAULTS[field.type]
+      return val.call(field) if val.respond_to?(:call)
+
+      val
+    end
+  end
+end

data/lib/wcc/contentful/test/double.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative './attributes'
+
+module WCC::Contentful::Test::Double
+  ##
+  # Builds a rspec double of the Contentful model for the given content_type.
+  # All attributes that are known to be required fields on the content type
+  # will return a default value based on the field type.
+  def contentful_double(content_type, **attrs)
+    const = WCC::Contentful::Model.resolve_constant(content_type)
+    attrs.symbolize_keys!
+
+    bad_attrs = attrs.reject { |a| const.instance_methods.include?(a) }
+    raise ArgumentError, "Attribute(s) do not exist on #{const}: #{bad_attrs.keys}" if bad_attrs.any?
+
+    double(attrs[:name] || attrs[:id] || nil, defaults(const).merge(attrs))
+  end
+
+  ##
+  # Builds an rspec double of a Contentful image asset, including the file
+  # URL and details.  These fields can be overridden.
+  def contentful_image_double(**attrs)
+    attrs = {
+      title: WCC::Contentful::Test::Attributes[:String],
+      description: WCC::Contentful::Test::Attributes[:String],
+      file: {
+        url: '//images.ctfassets.net/7yx6/2rak/test.jpg',
+        details: {
+          image: {
+            width: 0,
+            height: 0
+          }
+        }
+      }
+    }.deep_merge!(attrs)
+
+    attrs[:file] = OpenStruct.new(attrs[:file]) if attrs[:file]
+
+    attrs[:raw] = {
+      sys: {
+        space: {
+          sys: {
+            type: 'Link',
+            linkType: 'Space',
+            id: ENV['CONTENTFUL_SPACE_ID']
+          }
+        },
+        id: SecureRandom.urlsafe_base64,
+        type: 'Asset',
+        createdAt: Time.now.to_s(:iso8601),
+        updatedAt: Time.now.to_s(:iso8601),
+        environment: {
+          sys: {
+            id: 'master',
+            type: 'Link',
+            linkType: 'Environment'
+          }
+        },
+        revision: rand(100),
+        locale: 'en-US'
+      },
+      fields: attrs.each_with_object({}) { |(k, v), h| h[k] = { 'en-US' => v } }
+    }
+
+    double(attrs)
+  end
+
+  private
+
+  def defaults(model)
+    attributes = WCC::Contentful::Test::Attributes.defaults(model)
+    methods = model.instance_methods - WCC::Contentful::Model.instance_methods
+    methods.each_with_object(attributes) { |f, h| h[f] ||= nil }
+  end
+end

data/lib/wcc/contentful/test/factory.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative './attributes'
+
+module WCC::Contentful::Test::Factory
+  ##
+  # Builds a in-memory instance of the Contentful model for the given content_type.
+  # All attributes that are known to be required fields on the content type
+  # will return a default value based on the field type.
+  def contentful_create(content_type, context = nil, **attrs)
+    const = WCC::Contentful::Model.resolve_constant(content_type.to_s)
+    attrs = attrs.transform_keys { |a| a.to_s.camelize(:lower) }
+
+    id = attrs.delete('id')
+    sys = attrs.delete('sys')
+    raw = attrs.delete('raw') || default_raw(const, id)
+    bad_attrs = attrs.reject { |a| const.content_type_definition.fields.key?(a) }
+    raise ArgumentError, "Attribute(s) do not exist on #{const}: #{bad_attrs.keys}" if bad_attrs.any?
+
+    raw['sys'].merge!(sys) if sys
+
+    attrs.each do |k, v|
+      field = const.content_type_definition.fields[k]
+
+      raw_value = v
+      raw_value = to_raw(v, field.type) if %i[Asset Link].include?(field.type)
+      raw['fields'][field.name][raw.dig('sys', 'locale')] = raw_value
+    end
+
+    instance = const.new(raw, context)
+
+    attrs.each do |k, v|
+      field = const.content_type_definition.fields[k]
+      next unless %i[Asset Link].include?(field.type)
+
+      unless field.array ? v.any? { |i| i.is_a?(String) } : v.is_a?(String)
+        instance.instance_variable_set("@#{field.name}_resolved", v)
+      end
+    end
+
+    instance
+  end
+
+  private
+
+  def default_instance(model, id = nil)
+    model.new(default_raw(model, id))
+  end
+
+  def default_raw(model, id = nil)
+    { sys: contentful_sys(model, id), fields: contentful_fields(model) }.as_json
+  end
+
+  def contentful_sys(model, id = nil)
+    {
+      space: {
+        sys: {
+          type: 'Link',
+          linkType: 'Space',
+          id: ENV['CONTENTFUL_SPACE_ID']
+        }
+      },
+      id: id || SecureRandom.urlsafe_base64,
+      type: 'Entry',
+      createdAt: Time.now.to_s(:iso8601),
+      updatedAt: Time.now.to_s(:iso8601),
+      environment: {
+        sys: {
+          id: 'master',
+          type: 'Link',
+          linkType: 'Environment'
+        }
+      },
+      revision: rand(100),
+      contentType: {
+        sys: {
+          type: 'Link',
+          linkType: 'ContentType',
+          id: model.content_type
+        }
+      },
+      locale: 'en-US'
+    }
+  end
+
+  def contentful_fields(model)
+    WCC::Contentful::Test::Attributes.defaults(model).each_with_object({}) do |(k, v), h|
+      h[k] = { 'en-US' => v }
+    end
+  end
+
+  def to_raw(val, field_type)
+    if val.is_a? Array
+      val.map { |i| to_raw(i, field_type) }
+    elsif val.is_a? String
+      WCC::Contentful::Link.new(val, field_type).raw
+    elsif val
+      val.raw
+    end
+  end
+end

data/lib/wcc/contentful/version.rb

@@ -2,6 +2,6 @@
 
 module WCC
   module Contentful
-    VERSION = '0.3.0'
+    VERSION = '1.0.0-rc2'
   end
 end

data/wcc-contentful.gemspec

@@ -4,17 +4,24 @@ lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'wcc/contentful/version'
 
+doc_version = Gem::Version.new(WCC::Contentful::VERSION).release.to_s.sub(/\.\d+$/, '')
+
+# rubocop:disable Metrics/LineLength
 Gem::Specification.new do |spec|
   spec.name          = 'wcc-contentful'
   spec.version       = WCC::Contentful::VERSION
   spec.authors       = ['Watermark Dev']
   spec.email         = ['dev@watermark.org']
 
-  spec.summary       = File.readlines('README.md').join
-  spec.description   = 'Contentful API wrapper library for Watermark apps'
-  spec.homepage      = 'https://github.com/watermarkchurch/wcc-contentful'
+  spec.summary       = File.readlines(File.expand_path('README.md', __dir__)).join
+  spec.description   = 'Contentful API wrapper library exposing an ActiveRecord-like interface'
+  spec.homepage      = 'https://github.com/watermarkchurch/wcc-contentful/wcc-contentful'
   spec.license       = 'MIT'
 
+  spec.metadata = {
+    'documentation_uri' => "https://watermarkchurch.github.io/wcc-contentful/#{doc_version}/wcc-contentful"
+  }
+
   spec.required_ruby_version = '>= 2.3'
 
   spec.files         =
@@ -24,36 +31,43 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ['lib']
 
+  spec.add_development_dependency 'byebug', '~> 11.0.1'
+  spec.add_development_dependency 'coveralls'
   spec.add_development_dependency 'dotenv', '~> 2.2'
+  spec.add_development_dependency 'erb_lint', '~> 0.0.26'
   spec.add_development_dependency 'httplog', '~> 1.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.3.0'
-  spec.add_development_dependency 'rubocop', '~> 0.52'
-  spec.add_development_dependency 'vcr', '~> 4.0'
+  spec.add_development_dependency 'rspec-instrumentation-matcher'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.4.1'
+  spec.add_development_dependency 'rubocop', '0.68'
+  spec.add_development_dependency 'simplecov', '~> 0.16.1'
+  spec.add_development_dependency 'vcr', '~> 5.0'
   spec.add_development_dependency 'webmock', '~> 3.0'
+  spec.add_development_dependency 'wisper-rspec'
 
   # Makes testing easy via `bundle exec guard`
   spec.add_development_dependency 'guard', '~> 2.14'
   spec.add_development_dependency 'guard-rspec', '~> 4.7'
   spec.add_development_dependency 'guard-rubocop', '~> 1.3.0'
+  spec.add_development_dependency 'guard-shell', '~> 0.7.1'
 
   # for generators
   spec.add_development_dependency 'generator_spec', '~> 0.9.4'
-  spec.add_development_dependency 'rails', '~> 5.1'
-  spec.add_development_dependency 'rspec-rails', '~> 3.7'
-  spec.add_development_dependency 'sqlite3'
+  # spec.add_development_dependency 'rails', '~> 5.0'
+  # spec.add_development_dependency 'rspec-rails', '~> 3.7'
+  spec.add_development_dependency 'sqlite3', '~> 1.3.6'
   spec.add_development_dependency 'timecop', '~> 0.9.1'
 
   # optional dependencies
-  spec.add_development_dependency 'contentful', '2.6.0'
-  spec.add_development_dependency 'contentful-management', '2.0.2'
-  spec.add_development_dependency 'graphql', '~> 1.7'
+  spec.add_development_dependency 'connection_pool', '~> 2.2'
+  spec.add_development_dependency 'faraday', '~> 0.9'
   spec.add_development_dependency 'http', '> 1.0', '< 3.0'
   spec.add_development_dependency 'pg', '~> 1.0'
   spec.add_development_dependency 'typhoeus', '~> 1.3'
 
   spec.add_dependency 'activesupport', '>= 5'
-  spec.add_dependency 'dry-validation', '~> 0.11.1'
   spec.add_dependency 'wcc-base', '~> 0.3.1'
+  spec.add_dependency 'wisper', '~> 2.0.0'
 end
+# rubocop:enable Metrics/LineLength