wcc-contentful 0.0.3 → 0.1.0

data/lib/wcc/contentful/model/menu_button.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class WCC::Contentful::Model::MenuButton < WCC::Contentful::Model
+  validate_field :text, :String, :required
+  validate_field :icon, :Asset, :optional
+  validate_field :external_link, :String, :optional
+  validate_field :link, :Link, :optional, link_to: 'page'
+
+  # Gets either the external link or the slug from the referenced page.
+  # Example usage: `<%= link_to button.title, button.href %>`
+  def href
+    return external_link if external_link
+    link&.try(:slug) || link&.try(:url)
+  end
+end

data/lib/wcc/contentful/model_builder.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module WCC::Contentful
+  class ModelBuilder
+    include Helpers
+
+    def initialize(types)
+      @types = types
+    end
+
+    def build_models
+      @types.each_with_object([]) do |(_k, v), a|
+        a << build_model(v)
+      end
+    end
+
+    private
+
+    def build_model(typedef)
+      const = typedef.name
+      return WCC::Contentful::Model.const_get(const) if WCC::Contentful::Model.const_defined?(const)
+
+      # TODO: https://github.com/dkubb/ice_nine ?
+      typedef = typedef.deep_dup.freeze
+      fields = typedef.fields.keys
+      WCC::Contentful::Model.const_set(const,
+        Class.new(WCC::Contentful::Model) do
+          include Helpers
+
+          define_singleton_method(:content_type) do
+            typedef.content_type
+          end
+
+          define_singleton_method(:content_type_definition) do
+            typedef
+          end
+
+          define_singleton_method(:find) do |id, context = nil|
+            raw = WCC::Contentful::Model.store.find(id)
+            new(raw, context) if raw.present?
+          end
+
+          define_singleton_method(:find_all) do |context = nil|
+            raw = WCC::Contentful::Model.store.find_by(content_type: content_type)
+            raw.map { |r| new(r, context) }
+          end
+
+          define_singleton_method(:find_by) do |filter, context = nil|
+            filter.transform_keys! { |k| k.to_s.camelize(:lower) }
+            bad_fields = filter.keys.reject { |k| fields.include?(k) }
+            raise ArgumentError, "These fields do not exist: #{bad_fields}" unless bad_fields.empty?
+
+            query = WCC::Contentful::Model.store.find_by(content_type: content_type)
+            filter.each do |field, v|
+              query = query.eq(field, v, context)
+            end
+            query.map { |r| new(r, context) }
+          end
+
+          define_method(:initialize) do |raw, context = nil|
+            ct = content_type_from_raw(raw)
+            if ct != typedef.content_type
+              raise ArgumentError, 'Wrong Content Type - ' \
+                "'#{raw.dig('sys', 'id')}' is a #{ct}, expected #{typedef.content_type}"
+            end
+
+            @locale = context[:locale] if context.present?
+            @locale ||= 'en-US'
+            @id = raw.dig('sys', 'id')
+            @space = raw.dig('sys', 'space', 'sys', 'id')
+            @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?
+            @revision = raw.dig('sys', 'revision')
+
+            typedef.fields.each_value do |f|
+              raw_value = raw.dig('fields', f.name, @locale)
+              if raw_value.present?
+                case f.type
+                when :DateTime
+                  raw_value = Time.zone.parse(raw_value)
+                when :Int
+                  raw_value = Integer(raw_value)
+                when :Float
+                  raw_value = Float(raw_value)
+                end
+              end
+              instance_variable_set('@' + f.name, raw_value)
+            end
+          end
+
+          attr_reader :id
+          attr_reader :space
+          attr_reader :created_at
+          attr_reader :updated_at
+          attr_reader :revision
+
+          # Make a field for each column:
+          typedef.fields.each_value do |f|
+            name = f.name
+            var_name = '@' + name
+            case f.type
+            when :Asset, :Link
+              define_method(name) do
+                val = instance_variable_get(var_name + '_resolved')
+                return val if val.present?
+
+                return unless val = instance_variable_get(var_name)
+
+                val =
+                  if val.is_a? Array
+                    val.map { |v| WCC::Contentful::Model.find(v.dig('sys', 'id')) }
+                  else
+                    WCC::Contentful::Model.find(val.dig('sys', 'id'))
+                  end
+
+                instance_variable_set(var_name + '_resolved', val)
+                val
+              end
+            when :Coordinates
+              define_method(name) do
+                val = instance_variable_get(var_name)
+                OpenStruct.new(val.slice('lat', 'lon')) if val
+              end
+            when :Json
+              define_method(name) do
+                value = instance_variable_get(var_name)
+
+                parse_value =
+                  ->(v) do
+                    return v.to_h if v.respond_to?(:to_h)
+
+                    raise ArgumentError, "Cannot coerce value '#{value}' to a hash"
+                  end
+
+                return value.map { |v| OpenStruct.new(parse_value.call(v)) } if value.is_a?(Array)
+
+                OpenStruct.new(parse_value.call(value))
+              end
+            else
+              define_method(name) do
+                instance_variable_get(var_name)
+              end
+            end
+            alias_method name.underscore, name
+          end
+        end)
+    end
+  end
+end

data/lib/wcc/contentful/model_validators.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'dry-validation'
+
+require_relative 'model_validators/dsl'
+
+module WCC::Contentful::ModelValidators
+  def schema
+    return if @field_validations.nil? || @field_validations.empty?
+    field_validations = @field_validations
+
+    # "page": {
+    #   "sys": { ... }
+    #   "fields": {
+    #     "title": { ... },
+    #     "sections": { ... },
+    #     ...
+    #   }
+    # }
+
+    fields_schema =
+      Dry::Validation.Schema do
+        # Had to dig through the internals of Dry::Validation to find
+        # this magic incantation
+        field_validations.each { |dsl| instance_eval(&dsl.to_proc) }
+      end
+
+    Dry::Validation.Schema do
+      required('fields').schema(fields_schema)
+    end
+  end
+
+  def validate_fields(&block)
+    raise ArgumentError, 'validate_fields requires a block' unless block_given?
+    dsl = ProcDsl.new(Proc.new(&block))
+
+    (@field_validations ||= []) << dsl
+  end
+
+  def validate_field(field, type, *options)
+    dsl = FieldDsl.new(field, type, options)
+
+    (@field_validations ||= []) << dsl
+  end
+
+  # Accepts a content types response from the API and transforms it
+  # to be acceptible for the validator.
+  def self.transform_content_types_for_validation(content_types)
+    if !content_types.is_a?(Array) && items = content_types.try(:[], 'items')
+      content_types = items
+    end
+
+    # Transform the array into a hash keyed by content type ID
+    content_types.each_with_object({}) do |ct, ct_hash|
+      # Transform the fields into a hash keyed by field ID
+      ct['fields'] =
+        ct['fields'].each_with_object({}) do |f, f_hash|
+          f_hash[f['id']] = f
+        end
+
+      ct_hash[ct.dig('sys', 'id')] = ct
+    end
+  end
+end

data/lib/wcc/contentful/model_validators/dsl.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::ModelValidators
+  class ProcDsl
+    def to_proc
+      @proc
+    end
+
+    def initialize(proc)
+      @proc = proc
+    end
+  end
+
+  class FieldDsl
+    attr_reader :field
+
+    # "sections": {
+    #   "id": "sections",
+    #   "name": "Sections",
+    #   "type": "Array",
+    #   "localized": false,
+    #   "required": false,
+    #   "validations": [],
+    #   "disabled": false,
+    #   "omitted": false,
+    #   "items": {
+    #     "type": "Link",
+    #     "validations": [
+    #       {
+    #         "linkContentType": [
+    #           "Section"
+    #         ]
+    #       }
+    #     ],
+    #     "linkType": "Entry"
+    #   }
+    # }
+
+    def schema
+      return @field_schema if @field_schema
+
+      # example: required('type').value(...)
+      type_pred = parse_type_predicate(@type)
+
+      # example: [required('required').value(eq?: true), ...]
+      procs =
+        @options.map do |opt|
+          if opt.is_a?(Hash)
+            opt.map { |k, v| parse_option(k, v) }
+          else
+            parse_option(opt)
+          end
+        end
+
+      @field_schema =
+        Dry::Validation.Schema do
+          instance_eval(&type_pred)
+
+          procs.flatten.each { |p| instance_eval(&p) }
+        end
+    end
+
+    def to_proc
+      f = field
+      s = schema
+      proc { required(f).schema(s) }
+    end
+
+    def initialize(field, field_type, options)
+      @field = field.to_s.camelize(:lower) unless field.is_a?(String)
+      @type = field_type
+      @options = options
+    end
+
+    private
+
+    def parse_type_predicate(type)
+      case type
+      when :String
+        proc { required('type').value(included_in?: %w[Symbol Text]) }
+      when :Int
+        proc { required('type').value(eql?: 'Integer') }
+      when :Float
+        proc { required('type').value(eql?: 'Number') }
+      when :DateTime
+        proc { required('type').value(eql?: 'Date') }
+      when :Asset
+        proc {
+          required('type').value(eql?: 'Link')
+          required('linkType').value(eql?: 'Asset')
+        }
+      else
+        proc { required('type').value(eql?: type.to_s.camelize) }
+      end
+    end
+
+    def parse_option(option, option_arg = nil)
+      case option
+      when :required
+        proc { required('required').value(eql?: true) }
+      when :optional
+        proc { required('required').value(eql?: false) }
+      when :link_to
+        link_to_proc = parse_field_link_to(option_arg)
+        return link_to_proc unless @type.to_s.camelize == 'Array'
+        proc {
+          required('items').schema do
+            required('type').value(eql?: 'Link')
+            instance_eval(&link_to_proc)
+          end
+        }
+      when :items
+        type_pred = parse_type_predicate(option_arg)
+        proc {
+          required('items').schema do
+            instance_eval(&type_pred)
+          end
+        }
+      else
+        raise ArgumentError, "unknown validation requirement: #{option}"
+      end
+    end
+
+    def parse_field_link_to(option_arg)
+      raise ArgumentError, 'validation link_to: requires an argument' unless option_arg
+
+      # this works because a Link can only have one validation in its "validations" array -
+      # this will fail if Contentful ever changes that.
+
+      # the 'validations' schema needs to be optional because if we get the content
+      # types from the CDN instead of the management API, sometimes the validations
+      # don't get sent back.
+
+      # "validations": [
+      #   {
+      #     "linkContentType": [
+      #       "section-CardSearch",
+      #       "section-Faq",
+      #       "section-Testimonials",
+      #       "section-VideoHighlight"
+      #     ]
+      #   }
+      # ]
+
+      if option_arg.is_a?(Regexp)
+        return proc {
+          optional('validations').each do
+            schema do
+              required('linkContentType').each(format?: option_arg)
+            end
+          end
+        }
+      end
+
+      option_arg = [option_arg] unless option_arg.is_a?(Array)
+      proc {
+        optional('validations').each do
+          schema do
+            required('linkContentType').value(eql?: option_arg)
+          end
+        end
+      }
+    end
+  end
+end

data/lib/wcc/contentful/simple_client.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'http'
+
+require_relative 'simple_client/response'
+
+module WCC::Contentful
+  class SimpleClient
+    def initialize(api_url:, space:, access_token:, **options)
+      @api_url = URI.join(api_url, '/spaces/', space + '/')
+      @space = space
+      @access_token = access_token
+
+      @get_http = options[:override_get_http] if options[:override_get_http].present?
+
+      @options = options
+      @query_defaults = {}
+      @query_defaults[:locale] = @options[:default_locale] if @options[:default_locale]
+    end
+
+    def get(path, query = {})
+      url = URI.join(@api_url, path)
+
+      Response.new(self,
+        { url: url, query: query },
+        get_http(url, query))
+    end
+
+    private
+
+    def get_http(url, query, headers = {}, proxy = {})
+      headers = {
+        Authorization: "Bearer #{@access_token}"
+      }.merge(headers || {})
+
+      q = @query_defaults.dup
+      q = q.merge(query) if query
+
+      resp =
+        if @get_http
+          @get_http.call(url, q, headers, proxy)
+        else
+          default_get_http(url, q, headers, proxy)
+        end
+      if [301, 302, 307].include?(resp.code) && !@options[:no_follow_redirects]
+        resp = get_http(resp.headers['location'], nil, headers, proxy)
+      end
+      resp
+    end
+
+    def default_get_http(url, query, headers = {}, proxy = {})
+      if proxy[:host]
+        HTTP[headers].via(proxy[:host], proxy[:port], proxy[:username], proxy[:password])
+          .get(url, params: query)
+      else
+        HTTP[headers].get(url, params: query)
+      end
+    end
+
+    class Cdn < SimpleClient
+      def initialize(space:, access_token:, **options)
+        super(
+          api_url: options[:api_url] || 'https://cdn.contentful.com/',
+          space: space,
+          access_token: access_token,
+          **options
+        )
+      end
+
+      def entry(key, query = {})
+        resp = get("entries/#{key}", query)
+        resp.assert_ok!
+      end
+
+      def entries(query = {})
+        resp = get('entries', query)
+        resp.assert_ok!
+      end
+
+      def asset(key, query = {})
+        resp = get("assets/#{key}", query)
+        resp.assert_ok!
+      end
+
+      def assets(query = {})
+        resp = get('assets', query)
+        resp.assert_ok!
+      end
+
+      def content_types(query = {})
+        resp = get('content_types', query)
+        resp.assert_ok!
+      end
+
+      def sync(sync_token: nil, **query)
+        sync_token =
+          if sync_token
+            { sync_token: sync_token }
+          else
+            { initial: true }
+          end
+        query = query.merge(sync_token)
+        resp = SyncResponse.new(get('sync', query))
+        resp.assert_ok!
+      end
+    end
+
+    class Management < SimpleClient
+      def initialize(management_token:, **options)
+        super(
+          api_url: options[:api_url] || 'https://api.contentful.com',
+          space: options[:space] || '/',
+          access_token: management_token,
+          **options
+        )
+      end
+
+      def content_types(space: nil, **query)
+        space ||= @space
+        raise ArgumentError, 'please provide a space ID' if space.nil?
+
+        resp = get("/spaces/#{space}/content_types", query)
+        resp.assert_ok!
+      end
+    end
+  end
+end