wcc-contentful 0.2.2 → 0.3.0.pre.rc

data/lib/wcc/contentful.rb

@@ -8,82 +8,39 @@ require 'active_support/core_ext/object'
 require 'wcc/contentful/configuration'
 require 'wcc/contentful/exceptions'
 require 'wcc/contentful/helpers'
+require 'wcc/contentful/services'
 require 'wcc/contentful/simple_client'
 require 'wcc/contentful/store'
 require 'wcc/contentful/content_type_indexer'
-require 'wcc/contentful/model_validators'
 require 'wcc/contentful/model'
+require 'wcc/contentful/model_methods'
+require 'wcc/contentful/model_singleton_methods'
 require 'wcc/contentful/model_builder'
 
-##
 # The root namespace of the wcc-contentful gem
 #
 # Initialize the gem with the `configure` and `init` methods inside your
 # initializer.
 module WCC::Contentful
   class << self
-    ##
     # Gets the current configuration, after calling WCC::Contentful.configure
     attr_reader :configuration
 
-    ##
-    # Gets the sync token that was returned by the Contentful CDN after the most
-    # recent invocation of WCC::Contentful.sync!
-    attr_reader :next_sync_token
+    attr_reader :types
   end
 
-  ##
-  # Gets a {CDN Client}[rdoc-ref:WCC::Contentful::SimpleClient::Cdn] which provides
-  # methods for getting and paging raw JSON data from the Contentful CDN.
-  def self.client(preview: false)
-    if preview
-      configuration&.preview_client
-    else
-      configuration&.client
-    end
-  end
-
-  ##
-  # Gets the data-store which executes the queries run against the dynamic
-  # models in the WCC::Contentful::Model namespace.
-  # This is one of the following based on the configured content_delivery method:
-  #
-  # [:direct] an instance of WCC::Contentful::Store::CDNAdapter with a
-  #           {CDN Client}[rdoc-ref:WCC::Contentful::SimpleClient::Cdn] to access the CDN.
-  #
-  # [:lazy_sync] an instance of WCC::Contentful::Store::LazyCacheStore
-  #              with the configured ActiveSupport::Cache implementation and a
-  #              {CDN Client}[rdoc-ref:WCC::Contentful::SimpleClient::Cdn] for when data
-  #              cannot be found in the cache.
-  #
-  # [:eager_sync] an instance of the configured Store type, defined by
-  #               WCC::Contentful::Configuration.sync_store
-  #
-  def self.store
-    WCC::Contentful::Model.store
-  end
-
-  def self.preview_store
-    WCC::Contentful::Model.preview_store
-  end
-
-  ##
   # Configures the WCC::Contentful gem to talk to a Contentful space.
   # This must be called first in your initializer, before #init! or accessing the
   # client.
   def self.configure
     @configuration ||= Configuration.new
-    @next_sync_token = nil
     yield(configuration)
 
     configuration.validate!
 
-    configuration.configure_contentful
-
     configuration
   end
 
-  ##
   # Initializes the WCC::Contentful model-space and backing store.
   # This populates the WCC::Contentful::Model namespace with Ruby classes
   # that represent content types in the configured Contentful space.
@@ -91,24 +48,17 @@ module WCC::Contentful
   # These content types can be queried directly:
   #   WCC::Contentful::Model::Page.find('1xab...')
   # Or you can inherit from them in your own app:
-  #   class Page < WCC::Contentful::Model.page; end
+  #   class Page < WCC::Contentful::Model::Page; end
   #   Page.find_by(slug: 'about-us')
   def self.init!
     raise ArgumentError, 'Please first call WCC:Contentful.configure' if configuration.nil?
-    @mutex ||= Mutex.new
-
-    use_preview_client = false
-    # we want as much as possible the raw JSON from the API
-    content_types_resp =
-      if configuration.management_client
-        configuration.management_client.content_types(limit: 1000)
-      else
-        configuration.client.content_types(limit: 1000)
-      end
 
-    (use_preview_client = true) unless configuration.preview_client.nil?
+    # we want as much as possible the raw JSON from the API so use the management
+    # client if possible
+    client = Services.instance.management_client ||
+      Services.instance.client
 
-    @content_types = content_types_resp.items
+    @content_types = client.content_types(limit: 1000).items
 
     indexer =
       ContentTypeIndexer.new.tap do |ixr|
@@ -116,92 +66,14 @@ module WCC::Contentful
       end
     @types = indexer.types
 
-    if use_preview_client
-      store = configuration.store(preview: false)
-      WCC::Contentful::Model.store = store
-      preview_store = configuration.store(preview: use_preview_client)
-      WCC::Contentful::Model.preview_store = preview_store
-    else
-      store = configuration.store(preview: use_preview_client)
-      WCC::Contentful::Model.store = store
-    end
-
+    store = Services.instance.store
     if store.respond_to?(:index)
-      @next_sync_token = store.find("sync:#{configuration.space}:token")
-      sync!
+      # Drop an initial sync
+      WCC::Contentful::DelayedSyncJob.perform_later
     end
 
     WCC::Contentful::ModelBuilder.new(@types).build_models
 
-    # Extend all model types w/ validation & extra fields
-    @types.each_value do |t|
-      file = File.dirname(__FILE__) + "/contentful/model/#{t.name.underscore}.rb"
-      require file if File.exist?(file)
-    end
+    require_relative 'contentful/client_ext' if defined?(::Contentful)
   end
-
-  ##
-  # Runs validations over the content types returned from the Contentful API.
-  # Validations are configured on predefined model classes using the
-  # `validate_field` directive.  Example:
-  #    validate_field :top_button, :Link, :optional, link_to: 'menuButton'
-  # This results in a WCC::Contentful::ValidationError
-  # if the 'topButton' field in the 'menu' content type is not a link.
-  def self.validate_models!
-    # Ensure application models are loaded before we validate
-    Dir[Rails.root.join('app/models/**/*.rb')].each { |file| require file } if defined?(Rails)
-
-    content_types = WCC::Contentful::ModelValidators.transform_content_types_for_validation(
-      @content_types
-    )
-    errors = WCC::Contentful::Model.schema.call(content_types)
-    raise WCC::Contentful::ValidationError, errors.errors unless errors.success?
-  end
-
-  ##
-  # Calls the Contentful Sync API and updates the configured store with the returned
-  # data.
-  #
-  # 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 self.sync!(up_to_id: nil)
-    return unless store.respond_to?(:index)
-
-    @mutex.synchronize do
-      sync_resp = client.sync(sync_token: next_sync_token)
-
-      id_found = up_to_id.nil?
-
-      sync_resp.items.each do |item|
-        id = item.dig('sys', 'id')
-        id_found ||= id == up_to_id
-        store.index(item)
-      end
-      store.set("sync:#{configuration.space}:token", sync_resp.next_sync_token)
-      @next_sync_token = sync_resp.next_sync_token
-
-      unless id_found
-        raise SyncError, "ID '#{up_to_id}' did not come back via sync." unless defined?(Rails)
-        sync_later!(up_to_id: up_to_id)
-      end
-      next_sync_token
-    end
-  end
-
-  ##
-  # Drops an ActiveJob job to invoke WCC::Contentful.sync! after a given amount
-  # of time.
-  def self.sync_later!(up_to_id: nil, wait: 10.minutes)
-    raise NotImplementedError, 'Cannot sync_later! outside of a Rails app' unless defined?(Rails)
-
-    WCC::Contentful::DelayedSyncJob.set(wait: wait).perform_later(up_to_id)
-  end
-
-  # TODO: https://zube.io/watermarkchurch/development/c/2234 init graphql
-  # def self.init_graphql!
-  #   require 'wcc/contentful/graphql'
-  #   etc...
-  # end
 end

data/lib/wcc/contentful/client_ext.rb

@@ -5,11 +5,24 @@ class Contentful::Client
     alias_method :old_get_http, :get_http
   end
 
+  def self.adapter
+    @adapter ||=
+      WCC::Contentful::SimpleClient.load_adapter(WCC::Contentful.configuration.http_adapter) ||
+      ->(url, query, headers, proxy) { old_get_http(url, query, headers, proxy) }
+  end
+
   def self.get_http(url, query, headers = {}, proxy = {})
-    if override = WCC::Contentful.configuration.http_adapter
-      override.call(url, query, headers, proxy)
-    else
-      old_get_http(url, query, headers, proxy)
+    if environment = WCC::Contentful.configuration.environment
+      url = rewrite_to_environment(url, environment)
     end
+
+    adapter.call(url, query, headers, proxy)
+  end
+
+  REWRITE_REGEXP = /^(https?\:\/\/(?:\w+)\.contentful\.com\/spaces\/[^\/]+\/)(?!environments)(.+)$/
+  def self.rewrite_to_environment(url, environment)
+    return url unless m = REWRITE_REGEXP.match(url)
+
+    File.join(m[1], 'environments', environment, m[2])
   end
 end

data/lib/wcc/contentful/configuration.rb

@@ -3,6 +3,7 @@
 class WCC::Contentful::Configuration
   ATTRIBUTES = %i[
     access_token
+    app_url
     management_token
     space
     environment
@@ -13,23 +14,28 @@ class WCC::Contentful::Configuration
     sync_cache_store
     webhook_username
     webhook_password
+    webhook_jobs
   ].freeze
   attr_accessor(*ATTRIBUTES)
 
-  ##
+  # Returns true if the currently configured environment is pointing at `master`.
+  def master?
+    !environment.present?
+  end
+
   # Defines the method by which content is downloaded from the Contentful CDN.
   #
   # [:direct] `config.content_delivery = :direct`
   #           with the `:direct` method, all queries result in web requests to
   #           'https://cdn.contentful.com' via the
-  #           {SimpleClient}[rdoc-ref:WCC::Contentful::SimpleClient::Cdn]
+  #           {WCC::Contentful::SimpleClient::Cdn SimpleClient}
   #
   # [:eager_sync] `config.content_delivery = :eager_sync, [sync_store], [options]`
   #               with the `:eager_sync` method, the entire content of the Contentful
   #               space is downloaded locally and stored in the
-  #               {Sync Store}[rdoc-ref:WCC::Contentful.store].  The application is responsible
-  #               to periodically call `WCC::Contentful.sync!` to keep the store updated.
-  #               Alternatively, the provided {Engine}[WCC::Contentful::Engine]
+  #               {WCC::Contentful::Services#store configured store}.  The application is
+  #               responsible to periodically call `WCC::Contentful.sync!` to keep the store
+  #               updated. Alternatively, the provided {WCC::Contentful::Engine Engine}
   #               can be mounted to receive a webhook from the Contentful space
   #               on publish events:
   #                 mount WCC::Contentful::Engine, at: '/wcc/contentful'
@@ -51,6 +57,7 @@ class WCC::Contentful::Configuration
 
     WCC::Contentful::Store::Factory.new(
       self,
+      nil,
       cd,
       cd_params
     ).validate!
@@ -59,31 +66,18 @@ class WCC::Contentful::Configuration
     @content_delivery_params = cd_params
   end
 
-  ##
-  # Initializes the configured Sync Store.
-  def store(preview: false)
-    if preview
-      @preview_store ||= WCC::Contentful::Store::Factory.new(
-        self,
-        :direct,
-        [{ preview: preview }]
-      ).build_sync_store
-    else
-      @store ||= WCC::Contentful::Store::Factory.new(
-        self,
-        @content_delivery,
-        @content_delivery_params
-      ).build_sync_store
-    end
-  end
+  attr_reader :content_delivery_params
 
-  ##
   # Directly sets the adapter layer for communicating with Contentful
   def store=(value)
     @content_delivery = :custom
-    @store = value
+    store, *cd_params = value
+    @store = store
+    @content_delivery_params = cd_params
   end
 
+  attr_reader :store
+
   # Sets the adapter which is used to make HTTP requests.
   # If left unset, the gem attempts to load either 'http' or 'typhoeus'.
   # You can pass your own adapter which responds to 'call', or even a lambda
@@ -93,76 +87,23 @@ class WCC::Contentful::Configuration
 
   def initialize
     @access_token = ''
+    @app_url = ENV['APP_URL']
     @management_token = ''
     @preview_token = ''
     @space = ''
     @default_locale = nil
     @content_delivery = :direct
-  end
-
-  ##
-  # Gets a {CDN Client}[rdoc-ref:WCC::Contentful::SimpleClient::Cdn] which provides
-  # methods for getting and paging raw JSON data from the Contentful CDN.
-  attr_reader :client
-  attr_reader :management_client
-  attr_reader :preview_client
-
-  ##
-  # Called by WCC::Contentful.init! to configure the
-  # Contentful clients.  This method can be called independently of `init!` if
-  # the application would prefer not to generate all the models.
-  #
-  # If the {contentful.rb}[https://github.com/contentful/contentful.rb] gem is
-  # loaded, it is extended to make use of the `http_adapter` lambda.
-  def configure_contentful
-    @client = nil
-    @management_client = nil
-    @preview_client = nil
-
-    if defined?(::ContentfulModel)
-      ContentfulModel.configure do |config|
-        config.access_token = access_token
-        config.management_token = management_token if management_token.present?
-        config.space = space
-        config.default_locale = default_locale || 'en-US'
-      end
-    end
-
-    require_relative 'client_ext' if defined?(::Contentful)
-
-    @client = WCC::Contentful::SimpleClient::Cdn.new(
-      access_token: access_token,
-      space: space,
-      default_locale: default_locale,
-      adapter: http_adapter,
-      environment: environment
-    )
-
-    if preview_token.present?
-      @preview_client = WCC::Contentful::SimpleClient::Preview.new(
-        preview_token: preview_token,
-        space: space,
-        default_locale: default_locale,
-        adapter: http_adapter
-      )
-    end
-
-    return unless management_token.present?
-    @management_client = WCC::Contentful::SimpleClient::Management.new(
-      management_token: management_token,
-      space: space,
-      default_locale: default_locale,
-      adapter: http_adapter,
-      environment: environment
-    )
+    @webhook_jobs = []
   end
 
   def validate!
     raise ArgumentError, 'Please provide "space"' unless space.present?
     raise ArgumentError, 'Please provide "access_token"' unless access_token.present?
 
-    return if environment.nil? || %i[direct custom].include?(content_delivery)
-    raise ArgumentError, 'The Contentful Sync API currently does not work with environments.  ' \
-      'You can use the ":direct" content_delivery method, or provide a custom store implementation.'
+    webhook_jobs&.each do |job|
+      next if job.respond_to?(:call) || job.respond_to?(:perform_later)
+
+      raise ArgumentError, "The job '#{job}' must be an instance of ActiveJob::Base or respond to :call"
+    end
   end
 end

data/lib/wcc/contentful/engine.rb

@@ -4,6 +4,25 @@ 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
+        )
+      end
+    end
+
     config.generators do |g|
       g.test_framework :rspec, fixture: false
     end

data/lib/wcc/contentful/exceptions.rb

@@ -1,40 +1,37 @@
 # frozen_string_literal: true
 
 module WCC::Contentful
-  class ValidationError < StandardError
-    Message =
-      Struct.new(:path, :error) do
-        def to_s
-          "#{path}: #{error}"
-        end
-      end
+  class SyncError < StandardError
+  end
 
-    attr_reader :errors
+  # Raised when a constant under {WCC::Contentful::Model} does not match to a
+  # content type in the configured Contentful space
+  class ContentTypeNotFoundError < NameError
+  end
 
-    def initialize(errors)
-      @errors = ValidationError.join_msg_keys(errors)
-      super("Content Type Schema from Contentful failed validation!\n  #{@errors.join("\n  ")}")
-    end
+  # Raised when an entry contains a circular reference and cannot be represented
+  # as a flat tree.
+  class CircularReferenceError < StandardError
+    attr_reader :stack
+    attr_reader :id
 
-    # Turns the error messages hash into an array of message structs like:
-    # menu.fields.name.type: must be equal to String
-    def self.join_msg_keys(hash)
-      ret =
-        hash.map do |k, v|
-          if v.is_a?(Hash)
-            msgs = join_msg_keys(v)
-            msgs.map { |msg| Message.new(k.to_s + '.' + msg.path, msg.error) }
-          else
-            v.map { |msg| Message.new(k.to_s, msg) }
-          end
-        end
-      ret.flatten(1)
+    def initialize(stack, id)
+      @id = id
+      @stack = stack.slice(stack.index(id)..stack.length)
+      super('Circular reference detected!')
     end
-  end
 
-  class SyncError < StandardError
+    def message
+      return super unless stack
+
+      super + "\n  " \
+        "#{stack.last} points to #{id} which is also it's ancestor\n  " +
+        stack.join('->')
+    end
   end
 
-  class ContentTypeNotFoundError < NameError
+  # Raised by {WCC::Contentful::ModelMethods#resolve Model#resolve} when attempting
+  # to resolve an entry's links and that entry cannot be found in the space.
+  class ResolveError < StandardError
   end
 end