wcc-contentful 0.4.0.pre.beta → 1.0.0

data/lib/wcc/contentful/content_type_indexer.rb

@@ -6,6 +6,20 @@ module WCC::Contentful
   class ContentTypeIndexer
     include WCC::Contentful::Helpers
 
+    class << self
+      def load(schema_file)
+        from_json_schema(
+          JSON.parse(File.read(schema_file))['contentTypes']
+        )
+      end
+
+      def from_json_schema(schema)
+        new.tap do |ixr|
+          schema.each { |type| ixr.index(type) }
+        end
+      end
+    end
+
     attr_reader :types
 
     def initialize

data/lib/wcc/contentful/downloads_schema.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'wcc/contentful'
+
+class WCC::Contentful::DownloadsSchema
+  def self.call(file = nil, management_client: nil)
+    new(file, management_client: management_client).call
+  end
+
+  def initialize(file = nil, management_client: nil)
+    @client = management_client || WCC::Contentful::Services.instance.management_client
+    @file = file || WCC::Contentful.configuration&.schema_file
+    raise ArgumentError, 'Please configure your management token' unless @client
+    raise ArgumentError, 'Please pass filename or call WCC::Contentful.configure' unless @file
+  end
+
+  def call
+    return unless needs_update?
+
+    update!
+  end
+
+  def update!
+    FileUtils.mkdir_p(File.dirname(@file))
+
+    File.write(@file, format_json({
+      'contentTypes' => content_types,
+      'editorInterfaces' => editor_interfaces
+    }))
+  end
+
+  def needs_update?
+    return true unless File.exist?(@file)
+
+    contents =
+      begin
+        JSON.parse(File.read(@file))
+      rescue JSON::ParserError
+        return true
+      end
+
+    existing_cts = contents['contentTypes'].sort_by { |ct| ct.dig('sys', 'id') }
+    return true unless content_types.count == existing_cts.count
+    return true unless deep_contains_all(content_types, existing_cts)
+
+    existing_eis = contents['editorInterfaces'].sort_by { |i| i.dig('sys', 'contentType', 'sys', 'id') }
+    return true unless editor_interfaces.count == existing_eis.count
+
+    !deep_contains_all(editor_interfaces, existing_eis)
+  end
+
+  def content_types
+    @content_types ||=
+      @client.content_types(limit: 1000)
+        .items
+        .map { |ct| strip_sys(ct) }
+        .sort_by { |ct| ct.dig('sys', 'id') }
+  end
+
+  def editor_interfaces
+    @editor_interfaces ||=
+      content_types
+        .map { |ct| @client.editor_interface(ct.dig('sys', 'id')).raw }
+        .map { |i| sort_controls(strip_sys(i)) }
+        .sort_by { |i| i.dig('sys', 'contentType', 'sys', 'id') }
+  end
+
+  private
+
+  def strip_sys(obj)
+    obj.merge!({
+      'sys' => obj['sys'].slice('id', 'type', 'contentType')
+    })
+  end
+
+  def sort_controls(editor_interface)
+    {
+      'sys' => editor_interface['sys'],
+      'controls' => editor_interface['controls']
+        .sort_by { |c| c['fieldId'] }
+        .map { |c| c.slice('fieldId', 'settings', 'widgetId') }
+    }
+  end
+
+  def deep_contains_all(expected, actual)
+    if expected.is_a? Array
+      expected.each_with_index do |val, i|
+        return false unless actual[i]
+        return false unless deep_contains_all(val, actual[i])
+      end
+      true
+    elsif expected.is_a? Hash
+      expected.each do |(key, val)|
+        return false unless actual.key?(key)
+        return false unless deep_contains_all(val, actual[key])
+      end
+      true
+    else
+      expected == actual
+    end
+  end
+
+  def format_json(hash)
+    json_string = JSON.pretty_generate(hash)
+
+    # The pretty_generate format differs from contentful-shell and nodejs formats
+    # only in its treatment of empty arrays in the "validations" field.
+    json_string = json_string.gsub(/\[\n\n\s+\]/, '[]')
+    # contentful-shell also adds a newline at the end.
+    json_string + "\n"
+  end
+end

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