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

data/lib/wcc/contentful/engine.rb

@@ -2,29 +2,48 @@
 
 module WCC::Contentful
   class Engine < ::Rails::Engine
-    isolate_namespace WCC::Contentful
-
     initializer 'enable webhook' do
       config = WCC::Contentful.configuration
-      next unless config&.management_token.present?
-      next unless config.app_url.present?
 
-      if Rails.env.production?
-        WebhookEnableJob.set(wait: 10.seconds).perform_later(
-          management_token: config.management_token,
-          app_url: config.app_url,
-          space: config.space,
-          environment: config.environment,
-          default_locale: config.default_locale,
-          adapter: config.http_adapter,
-          webhook_username: config.webhook_username,
-          webhook_password: config.webhook_password
+      jobs = []
+      if WCC::Contentful::Services.instance.sync_engine&.should_sync?
+        jobs << WCC::Contentful::SyncEngine::Job
+      end
+      jobs.push(*WCC::Contentful.configuration.webhook_jobs)
+
+      jobs.each do |job|
+        WCC::Contentful::WebhookController.subscribe(
+          ->(event) do
+            begin
+              if job.respond_to?(:perform_later)
+                job.perform_later(event.to_h)
+              else
+                Rails.logger.error "Misconfigured webhook job: #{job} does not respond to " \
+                  ':perform_later'
+              end
+            rescue StandardError => e
+              warn "Error in job #{job}: #{e}"
+              Rails.logger.error "Error in job #{job}: #{e}"
+            end
+          end,
+          with: :call
         )
       end
+
+      next unless config&.management_token.present?
+      next unless config.app_url.present?
+
+      WebhookEnableJob.set(wait: 10.seconds).perform_later if Rails.env.production?
     end
 
     config.generators do |g|
       g.test_framework :rspec, fixture: false
     end
+
+    # Clear the model registry to allow dev reloads to work properly
+    # https://api.rubyonrails.org/classes/Rails/Railtie/Configuration.html#method-i-to_prepare
+    config.to_prepare do
+      WCC::Contentful::Model.reload!
+    end
   end
 end

data/lib/wcc/contentful/event.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module WCC::Contentful::Event
+  extend ActiveSupport::Concern
+
+  # 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)
+    const = Registry.instance.get(raw.dig('sys', 'type'))
+
+    const.new(raw, context)
+  end
+
+  class Registry
+    include Singleton
+
+    def get(name)
+      @event_types ||= {}
+      @event_types[name] || WCC::Contentful::Event::Unknown
+    end
+
+    def register(constant)
+      name = constant.try(:type) || constant.name.demodulize
+      unless constant.respond_to?(:new)
+        raise ArgumentError, "Constant #{constant} does not define 'new'"
+      end
+
+      @event_types ||= {}
+      @event_types[name] = constant
+    end
+  end
+
+  included do
+    Registry.instance.register(self)
+
+    def initialize(raw, context = nil, source: nil)
+      @raw = raw.freeze
+      @source = source
+
+      created_at = raw.dig('sys', 'createdAt')
+      created_at = Time.parse(created_at) if created_at.present?
+      updated_at = raw.dig('sys', 'updatedAt')
+      updated_at = Time.parse(updated_at) if updated_at.present?
+      @sys = WCC::Contentful::Sys.new(
+        raw.dig('sys', 'id'),
+        raw.dig('sys', 'type'),
+        raw.dig('sys', 'locale') || context.try(:[], :locale) || 'en-US',
+        raw.dig('sys', 'space', 'sys', 'id'),
+        created_at,
+        updated_at,
+        raw.dig('sys', 'revision'),
+        OpenStruct.new(context).freeze
+      )
+    end
+
+    attr_reader :sys
+    attr_reader :raw
+    attr_reader :source
+    delegate :id, to: :sys
+    delegate :type, to: :sys
+    delegate :created_at, to: :sys
+    delegate :updated_at, to: :sys
+    delegate :revision, to: :sys
+    delegate :space, to: :sys
+
+    delegate :dig, :[], to: :to_h
+    delegate :to_h, to: :raw
+  end
+end
+
+class WCC::Contentful::Event::Entry
+  include WCC::Contentful::Event
+
+  def content_type
+    raw.dig('sys', 'contentType', 'sys', 'id')
+  end
+
+  def entry
+    @entry ||= WCC::Contentful::Model.new_from_raw(raw, sys.context)
+  end
+end
+
+class WCC::Contentful::Event::Asset
+  include WCC::Contentful::Event
+
+  def content_type
+    'Asset'
+  end
+
+  def asset
+    @asset ||= WCC::Contentful::Model.new_from_raw(raw, sys.context)
+  end
+
+  alias_method :entry, :asset
+end
+
+class WCC::Contentful::Event::DeletedEntry
+  include WCC::Contentful::Event
+
+  def deleted_at
+    raw.dig('sys', 'deletedAt')
+  end
+
+  def content_type
+    raw.dig('sys', 'contentType', 'sys', 'id')
+  end
+
+  def entry
+    @entry ||= WCC::Contentful::Model.new_from_raw(raw, sys.context)
+  end
+end
+
+class WCC::Contentful::Event::DeletedAsset
+  include WCC::Contentful::Event
+
+  def deleted_at
+    raw.dig('sys', 'deletedAt')
+  end
+
+  def content_type
+    'Asset'
+  end
+
+  def asset
+    @asset ||= WCC::Contentful::Model.new_from_raw(raw, sys.context)
+  end
+
+  alias_method :entry, :asset
+end
+
+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(
+      nil,
+      'Array',
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+      OpenStruct.new(context).freeze
+    )
+  end
+
+  attr_reader :sys, :items, :source
+
+  def to_h
+    {
+      'sys' => {
+        'type' => 'Array'
+      },
+      'items' => items.map(&:to_h)
+    }
+  end
+end
+
+class WCC::Contentful::Event::Unknown
+  include WCC::Contentful::Event
+end

data/lib/wcc/contentful/events.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'wisper'
+require 'singleton'
+
+# WCC::Contentful::Events is a singleton which rebroadcasts Contentful update
+# events.  You can subscribe to these events in your initializer using the
+# [wisper gem syntax](https://github.com/krisleech/wisper).
+# All published events are in the namespace WCC::Contentful::Event.
+class WCC::Contentful::Events
+  include Wisper::Publisher
+
+  def self.instance
+    @instance ||= new
+  end
+
+  def initialize
+    _attach_listeners
+  end
+
+  def rebroadcast(event)
+    type = event.dig('sys', 'type')
+    raise ArgumentError, "Unknown event type #{event}" unless type.present?
+
+    broadcast(type, event)
+  end
+
+  private
+
+  def _attach_listeners
+    publishers = [
+      WCC::Contentful::Services.instance.sync_engine
+    ]
+
+    publishers << WCC::Contentful::WebhookController if defined?(Rails)
+
+    publishers.each do |publisher|
+      publisher.subscribe(self, with: :rebroadcast) if publisher.present?
+    end
+  end
+end

data/lib/wcc/contentful/exceptions.rb

@@ -34,4 +34,7 @@ module WCC::Contentful
   # to resolve an entry's links and that entry cannot be found in the space.
   class ResolveError < StandardError
   end
+
+  class InitializationError < StandardError
+  end
 end

data/lib/wcc/contentful/indexed_representation.rb

@@ -29,8 +29,8 @@ module WCC::Contentful
       ret
     end
 
-    def to_json
-      @types.to_json
+    def to_json(*args)
+      @types.to_json(*args)
     end
 
     def deep_dup

data/lib/wcc/contentful/instrumentation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module WCC::Contentful
+  module Instrumentation
+    extend ActiveSupport::Concern
+
+    def _instrumentation_event_prefix
+      @_instrumentation_event_prefix ||=
+        # WCC::Contentful => contentful.wcc
+        '.' + (is_a?(Class) || is_a?(Module) ? self : self.class)
+          .name.parameterize.split('-').reverse.join('.')
+    end
+
+    included do
+      protected
+
+      def _instrument(name, payload = {}, &block)
+        name += _instrumentation_event_prefix
+        (@_instrumentation ||= WCC::Contentful::Services.instance.instrumentation)
+          .instrument(name, payload, &block)
+      end
+    end
+
+    class << self
+      def instrument(name, payload = {}, &block)
+        WCC::Contentful::Services.instance
+          .instrumentation.instrument(name, payload, &block)
+      end
+    end
+  end
+end

data/lib/wcc/contentful/link.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class WCC::Contentful::Link
+  attr_reader :id
+  attr_reader :link_type
+  attr_reader :raw
+
+  LINK_TYPES = {
+    Asset: 'Asset',
+    Link: 'Entry'
+  }.freeze
+
+  def initialize(model, link_type = nil)
+    @id = model.try(:id) || model
+    @link_type = link_type
+    @link_type ||= model.is_a?(WCC::Contentful::Model::Asset) ? :Asset : :Link
+    @raw =
+      {
+        'sys' => {
+          'type' => 'Link',
+          'linkType' => LINK_TYPES[@link_type] || link_type,
+          'id' => @id
+        }
+      }
+  end
+
+  alias_method :to_h, :raw
+end

data/lib/wcc/contentful/link_visitor.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# The LinkVisitor is a utility class for walking trees of linked entries.
+# It is used internally by the Store layer to compose the resulting resolved hashes.
+# But you can use it too!
+class WCC::Contentful::LinkVisitor
+  attr_reader :entry
+  attr_reader :type
+  attr_reader :fields
+  attr_reader :depth
+
+  # @param [Hash] entry The entry hash (resolved or unresolved) to walk
+  # @param [Array<String, Symbol>] The fields to select from the entry tree.
+  #         Use `:Link` to select only links, or `'slug'` to select all slugs in the tree.
+  # @param [Fixnum] depth (optional) How far to walk down the tree of links.  Be careful of
+  #         recursive trees!
+  # @example
+  #   entry = store.find_by(id: id, include: 3)
+  #   WCC::Contentful::LinkVisitor.new(entry, 'slug', depth: 3)
+  #     .map { |slug| 'https://mirror-site' + slug }
+  def initialize(entry, *fields, depth: 0)
+    unless entry.is_a?(Hash) && entry.dig('sys', 'id')
+      raise ArgumentError, "Please provide an entry as a hash value (got #{entry})"
+    end
+    unless ct = entry.dig('sys', 'contentType', 'sys', 'id')
+      raise ArgumentError, 'Entry has no content type!'
+    end
+
+    @type = WCC::Contentful.types[ct]
+    raise ArgumentError, "Unknown content type '#{ct}'" unless @type
+
+    @entry = entry
+    @fields = fields
+    @depth = depth
+  end
+
+  # Walks an entry and its resolved links, without transforming the entry.
+  # @yield [value, field, locale]
+  # @yieldparam [Object] value The value of the selected field.
+  # @yieldparam [WCC::Contentful::IndexedRepresentation::Field] field The type of the selected field
+  # @yieldparam [String] locale The locale of the current field value
+  # @returns nil
+  def each(&block)
+    _each do |val, field, locale, index|
+      yield(val, field, locale, index) if should_yield_field?(field)
+
+      next unless should_walk_link?(field, val)
+
+      self.class.new(val, *fields, depth: depth - 1).each(&block)
+    end
+
+    nil
+  end
+
+  def map!(&block)
+    _each do |val, field, locale, index|
+      if should_yield_field?(field)
+        val = yield(val, field, locale, index)
+        set_field(field, locale, index, val)
+      end
+
+      next unless should_walk_link?(field, val)
+
+      self.class.new(val, *fields, depth: depth - 1).map!(&block)
+    end
+
+    entry
+  end
+
+  private
+
+  def _each(&block)
+    type.fields.each_value do |f|
+      each_field(f, &block)
+    end
+  end
+
+  def each_field(field)
+    each_locale(field) do |val, locale|
+      if field.array
+        val&.each_with_index do |v, index|
+          yield(v, field, locale, index) unless v.nil?
+        end
+      else
+        yield(val, field, locale) unless val.nil?
+      end
+    end
+  end
+
+  def each_locale(field)
+    raw_value = entry.dig('fields', field.name)
+    if locale = entry.dig('sys', 'locale')
+      if raw_value.is_a?(Hash) && raw_value[locale]
+        # it's a locale=* entry, but they've added sys.locale to those now
+        raw_value = raw_value[locale]
+      end
+      yield(raw_value, locale)
+    else
+      raw_value&.each_with_object({}) do |(l, val), h|
+        h[l] = yield(val, l)
+      end
+    end
+  end
+
+  def should_yield_field?(field)
+    fields.empty? || fields.include?(field.type) || fields.include?(field.name)
+  end
+
+  def should_walk_link?(field, val, dep = depth)
+    dep > 0 && field.type == :Link && val.dig('sys', 'type') == 'Entry'
+  end
+
+  def set_field(field, locale, index, val)
+    current_field = (entry['fields'][field.name] ||= {})
+
+    if field.array
+      (current_field[locale] ||= [])[index] = val
+    else
+      current_field[locale] = val
+    end
+  end
+end