wcc-contentful 0.0.3 → 0.1.0

data/lib/generators/wcc/templates/menu/menu.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# This file reopens the "Menu" class which was dynamically
+# created by the WCC::Contentful gem.  This class does not need to do anything,
+# the attributes have already been defined based on the `content_type` returned
+# from the Contentful API.  However you can reopen the class to add functionality.
+class WCC::Contentful::Model::Menu < WCC::Contentful::Model
+
+  # Add custom validations to ensure that app-specific properties exist:
+  # validate_field :foo, :String, :required
+  # validate_field :bar_links, :Array, link_to: %w[bar baz]
+
+  # Override functionality or add utilities
+  #
+  # # Example: override equality
+  # def ===(other)
+  #   ...
+  # end
+  #
+  # # Example: override "name" attribute to always be camelized.
+  # #          `@name` is populated by the gem in the initializer.
+  # def name
+  #   @name_camelized ||= @name.camelize(true)
+  # end
+end

data/lib/generators/wcc/templates/menu/menu_button.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# This file reopens the "MenuButton" class which was dynamically
+# created by the WCC::Contentful gem.  This class does not need to do anything,
+# the attributes have already been defined based on the `content_type` returned
+# from the Contentful API.  However you can reopen the class to add functionality.
+class WCC::Contentful::Model::MenuButton < WCC::Contentful::Model
+
+  # Add custom validations to ensure that app-specific properties exist:
+  # validate_field :foo, :String, :required
+  # validate_field :bar_links, :Array, link_to: %w[bar baz]
+
+  # Override functionality or add utilities
+  #
+  # # Example: override equality
+  # def ===(other)
+  #   ...
+  # end
+  #
+  # # Example: override "text" attribute to always be camelized.
+  # #          `@text` is populated by the gem in the initializer.
+  # def text
+  #   @text_camelized ||= @text.camelize(true)
+  # end
+end

data/lib/generators/wcc/templates/release

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+set -e
+
+echo "Migrating database..."
+bundle exec rake db:migrate
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+$DIR/contentful migrate -y

data/lib/generators/wcc/templates/wcc_contentful.rb

@@ -0,0 +1,18 @@
+
+WCC::Contentful.configure do |config|
+  # Required
+  config.access_token = # Contentful CDN access token
+  config.space = # Contentful Space ID
+
+  # Optional
+  config.management_token = # Contentful API management token
+  config.default_locale = # Set default locale, if left blank this is 'en-US'
+  config.content_delivery = # :direct, :eager_sync, or :lazy_sync
+  config.sync_store = # :memory, :postgres, or a custom implementation
+end
+
+# Download content types, build models, and sync content
+WCC::Contentful.init!
+
+# Validate that models conform to a defined specification
+WCC::Contentful.validate_models! unless defined?(Rails) && Rails.env.development?

data/lib/wcc/contentful.rb

@@ -1,38 +1,105 @@
-require "wcc/contentful/version"
-require 'contentful_model'
+# frozen_string_literal: true
 
-module WCC
-  module Contentful
+require 'wcc/contentful/version'
 
-    class << self
-      attr_accessor :configuration
-    end
+require 'active_support'
+require 'active_support/core_ext/object'
 
-    def self.configure
-      self.configuration ||= Configuration.new
-      yield(configuration)
-      Configuration.configure_contentful_model
-    end
+require 'wcc/contentful/configuration'
+require 'wcc/contentful/exceptions'
+require 'wcc/contentful/helpers'
+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_builder'
+
+module WCC::Contentful
+  class << self
+    attr_reader :configuration
+  end
+
+  def self.client
+    configuration&.client
+  end
+
+  def self.configure
+    @configuration ||= Configuration.new
+    yield(configuration)
 
-    class Configuration
-      attr_accessor :access_token, :space, :default_locale
+    configuration.configure_contentful
 
-      def initialize
-        @access_token = ""
-        @space = ""
-        @default_locale = ""
+    raise ArgumentError, 'Please provide "space" ID' unless configuration.space.present?
+    raise ArgumentError, 'Please provide "access_token"' unless configuration.access_token.present?
+
+    configuration
+  end
+
+  def self.init!
+    raise ArgumentError, 'Please first call WCC:Contentful.configure' if configuration.nil?
+
+    # 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
+    @content_types = content_types_resp.items
 
-      def self.configure_contentful_model
-        ContentfulModel.configure do |config|
-          config.access_token = WCC::Contentful.configuration.access_token
-          config.space = WCC::Contentful.configuration.space
-          config.default_locale = WCC::Contentful.configuration.default_locale
-        end
+    indexer =
+      ContentTypeIndexer.new.tap do |ixr|
+        @content_types.each { |type| ixr.index(type) }
       end
+    @types = indexer.types
+
+    case configuration.content_delivery
+    when :eager_sync
+      store = configuration.sync_store
+
+      client.sync(initial: true).items.each do |item|
+        # TODO: enrich existing type data using Sync::Indexer
+        store.index(item.dig('sys', 'id'), item)
+      end
+      WCC::Contentful::Model.store = store
+    when :direct
+      store = Store::CDNAdapter.new(client)
+      WCC::Contentful::Model.store = store
+    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
 
+    return unless defined?(Rails)
+    Dir[Rails.root.join('lib/wcc/contentful/model/**/*.rb')].each { |file| require file }
   end
-end
 
-require "wcc/contentful/redirect"
+  def self.validate_models!
+    schema =
+      Dry::Validation.Schema do
+        WCC::Contentful::Model.all_models.each do |klass|
+          next unless klass.schema
+          ct = klass.try(:content_type) || klass.name.demodulize
+          required(ct).schema(klass.schema)
+        end
+      end
+
+    content_types = WCC::Contentful::ModelValidators.transform_content_types_for_validation(
+      @content_types
+    )
+    errors = schema.call(content_types)
+    raise WCC::Contentful::ValidationError, errors.errors unless errors.success?
+  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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Contentful::Client
+  class << self
+    alias_method :old_get_http, :get_http
+  end
+
+  def self.get_http(url, query, headers = {}, proxy = {})
+    if override = WCC::Contentful.configuration.override_get_http
+      override.call(url, query, headers, proxy)
+    else
+      old_get_http(url, query, headers, proxy)
+    end
+  end
+end

data/lib/wcc/contentful/configuration.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'http'
+
+class WCC::Contentful::Configuration
+  ATTRIBUTES = %i[
+    access_token
+    management_token
+    space
+    default_locale
+    content_delivery
+    override_get_http
+  ].freeze
+  attr_accessor(*ATTRIBUTES)
+
+  CDN_METHODS = [
+    :eager_sync,
+    # TODO: :lazy_sync
+    :direct
+  ].freeze
+
+  SYNC_STORES = {
+    memory: ->(_config) { WCC::Contentful::Store::MemoryStore.new },
+    postgres: ->(_config) {
+      require_relative 'store/postgres_store'
+      WCC::Contentful::Store::PostgresStore.new(ENV['POSTGRES_CONNECTION'])
+    }
+  }.freeze
+
+  def content_delivery=(symbol)
+    raise ArgumentError, "Please set one of #{CDN_METHODS}" unless CDN_METHODS.include?(symbol)
+    @content_delivery = symbol
+  end
+
+  def sync_store=(symbol)
+    if symbol.is_a? Symbol
+      unless SYNC_STORES.keys.include?(symbol)
+        raise ArgumentError, "Please use one of #{SYNC_STORES.keys}"
+      end
+    end
+    @sync_store = symbol
+  end
+
+  def sync_store
+    @sync_store = SYNC_STORES[@sync_store].call(self) if @sync_store.is_a? Symbol
+    @sync_store ||= Store::MemoryStore.new
+  end
+
+  # A proc which overrides the "get_http" function in Contentful::Client.
+  # All interaction with Contentful will go through this function.
+  # Should be a lambda like: ->(url, query, headers = {}, proxy = {}) { ... }
+  attr_writer :override_get_http
+
+  def initialize
+    @access_token = ''
+    @management_token = ''
+    @space = ''
+    @default_locale = nil
+    @content_delivery = :direct
+    @sync_store = :memory
+  end
+
+  attr_reader :client
+  attr_reader :management_client
+
+  def configure_contentful
+    @client = nil
+    @management_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
+    )
+    return unless management_token.present?
+    @management_client = WCC::Contentful::SimpleClient::Management.new(
+      management_token: management_token,
+      space: space,
+      default_locale: default_locale
+    )
+  end
+end

data/lib/wcc/contentful/content_type_indexer.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative 'indexed_representation'
+
+module WCC::Contentful
+  class ContentTypeIndexer
+    include WCC::Contentful::Helpers
+
+    attr_reader :types
+
+    def initialize
+      @types = IndexedRepresentation.new({
+        'Asset' => create_asset_type
+      })
+    end
+
+    def index(content_type)
+      content_type =
+        if content_type.respond_to?(:fields)
+          create_type(content_type.id, content_type.fields)
+        else
+          create_type(content_type.dig('sys', 'id'), content_type['fields'])
+        end
+
+      @types[content_type.content_type] = content_type
+    end
+
+    def create_type(content_type_id, fields)
+      content_type = IndexedRepresentation::ContentType.new({
+        name: constant_from_content_type(content_type_id),
+        content_type: content_type_id
+      })
+
+      fields.each do |f|
+        field = create_field(f)
+        content_type.fields[field.name] = field
+      end
+
+      content_type
+    end
+
+    # hardcoded because the Asset type is a "magic type" in their system
+    def create_asset_type
+      IndexedRepresentation::ContentType.new({
+        name: 'Asset',
+        content_type: 'Asset',
+        fields: {
+          'title' => { name: 'title', type: :String },
+          'description' => { name: 'description', type: :String },
+          'file' => { name: 'file', type: :Json }
+        }
+      })
+    end
+
+    private
+
+    def create_field(field)
+      if field.respond_to?(:raw)
+        create_field_from_raw(field.raw)
+      elsif field.respond_to?(:to_h)
+        create_field_from_raw(field.to_h)
+      else
+        create_field_from_managed(field)
+      end
+    end
+
+    def create_field_from_managed(managed_field)
+      field = IndexedRepresentation::Field.new({
+        name: managed_field.id,
+        type: find_field_type(managed_field),
+        required: managed_field.required
+      })
+      field.array = true if managed_field.type == 'Array'
+
+      if field.type == :Link
+        validations =
+          if field.array
+            managed_field.items.validations
+          else
+            managed_field.validations
+          end
+        field.link_types = resolve_managed_link_types(validations) if validations.present?
+      end
+      field
+    end
+
+    def create_field_from_raw(raw_field)
+      field_name = raw_field['id']
+      field = IndexedRepresentation::Field.new({
+        name: field_name,
+        type: find_field_type(raw_field),
+        required: raw_field['required']
+      })
+      field.array = true if raw_field['type'] == 'Array'
+
+      if field.type == :Link
+        validations =
+          if field.array
+            raw_field.dig('items', 'validations')
+          else
+            raw_field['validations']
+          end
+        field.link_types = resolve_raw_link_types(validations) if validations.present?
+      end
+      field
+    end
+
+    def find_field_type(field)
+      # 'Symbol' | 'Text' | 'Integer' | 'Number' | 'Date' | 'Boolean' |
+      #  'Object' | 'Location' | 'Array' | 'Link'
+      case raw_type = field.try(:type) || field['type']
+      when 'Symbol', 'Text'
+        :String
+      when 'Integer'
+        :Int
+      when 'Number'
+        :Float
+      when 'Date'
+        :DateTime
+      when 'Boolean'
+        :Boolean
+      when 'Object'
+        :Json
+      when 'Location'
+        :Coordinates
+      when 'Array'
+        find_field_type(field.try(:items) || field['items'])
+      when 'Link'
+        case link_type = field.try(:link_type) || field['linkType']
+        when 'Entry'
+          :Link
+        when 'Asset'
+          :Asset
+        else
+          raise ArgumentError,
+            "Unknown link type #{link_type} for field #{field.try(:id) || field['id']}"
+        end
+      else
+        raise ArgumentError, "unknown field type #{raw_type} for field #{field.try(:id) || field['id']}"
+      end
+    end
+
+    def resolve_managed_link_types(validations)
+      validation = validations.find { |v| v.link_content_type.present? }
+      validation.link_content_type if validation.present?
+    end
+
+    def resolve_raw_link_types(validations)
+      validation = validations.find { |v| v['linkContentType'].present? }
+      validation['linkContentType'] if validation.present?
+    end
+  end
+end