wcc-contentful 0.3.0 → 1.0.0.pre.rc2

data/lib/wcc/contentful/graphql/types.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module WCC::Contentful::Graphql::Types
-  DateTimeType =
-    GraphQL::ScalarType.define do
-      name 'DateTime'
-
-      coerce_result ->(value, _ctx) { Time.zone.parse(value) }
-    end
-
-  HashType =
-    GraphQL::ScalarType.define do
-      name 'Hash'
-
-      coerce_result ->(value, _ctx) {
-        return value if value.is_a? Array
-        return value.to_h if value.respond_to?(:to_h)
-        return JSON.parse(value) if value.is_a? String
-
-        raise ArgumentError, "Cannot coerce value '#{value}' to a hash"
-      }
-    end
-
-  CoordinatesType =
-    GraphQL::ObjectType.define do
-      name 'Coordinates'
-
-      field :lat, !types.Float, hash_key: 'lat'
-      field :lon, !types.Float, hash_key: 'lon'
-    end
-
-  AnyScalarInputType =
-    GraphQL::ScalarType.define do
-      name 'Any'
-    end
-
-  FilterType =
-    GraphQL::InputObjectType.define do
-      name 'filter'
-
-      argument :field, !types.String
-      argument :eq, AnyScalarInputType
-    end
-
-  BuildUnionType =
-    ->(from_types, union_type_name) do
-      possible_types = from_types.values.reject { |t| t.is_a? GraphQL::UnionType }
-
-      GraphQL::UnionType.define do
-        name union_type_name
-        possible_types possible_types
-      end
-    end
-end

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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class WCC::Contentful::Model::DropdownMenu < WCC::Contentful::Model
-  validate_field :name, :String
-  validate_field :label, :Link, link_to: 'menuButton'
-  validate_field :items, :Array, link_to: 'menuButton'
-end

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

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-class WCC::Contentful::Model::Menu < WCC::Contentful::Model
-  validate_field :name, :String
-  validate_field :items, :Array, link_to: %w[dropdownMenu menuButton]
-end

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

@@ -1,16 +0,0 @@
-# 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/page.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class WCC::Contentful::Model::Page < WCC::Contentful::Model
-  validate_field :title, :String
-  validate_field :slug, :String
-  validate_field :subpages, :Array, link_to: %w[page]
-  validate_field :sections, :Array, link_to: /^section/
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class WCC::Contentful::Model::Redirect < WCC::Contentful::Model
-  def href
-    if !url.nil?
-      url
-    elsif valid_page_reference?(pageReference)
-      "/#{pageReference.url}"
-    end
-  end
-
-  def valid_page_reference?(page_ref)
-    if !page_ref.nil? && !defined?(page_ref.url).nil?
-      true
-    else
-      false
-    end
-  end
-end

data/lib/wcc/contentful/model_validators.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry-validation'
-
-require_relative 'model_validators/dsl'
-
-module WCC::Contentful::ModelValidators
-  def schema
-    return if validations.nil? || validations.empty?
-
-    all_field_validations =
-      validations.each_with_object({}) do |(content_type, procs), h|
-        next if procs.empty?
-
-        # "page": {
-        #   "sys": { ... }
-        #   "fields": {
-        #     "title": { ... },
-        #     "sections": { ... },
-        #     ...
-        #   }
-        # }
-        h[content_type] =
-          Dry::Validation.Schema do
-            # Had to dig through the internals of Dry::Validation to find
-            # this magic incantation
-            procs.each { |dsl| instance_eval(&dsl.to_proc) }
-          end
-      end
-
-    Dry::Validation.Schema do
-      all_field_validations.each do |content_type, fields_schema|
-        required(content_type).schema do
-          required('fields').schema(fields_schema)
-        end
-      end
-    end
-  end
-
-  def validations
-    # This needs to be a class variable so that subclasses defined in application
-    # code can add to the total package of model validations
-    # rubocop:disable Style/ClassVars
-    @@validations ||= {}
-    # rubocop:enable Style/ClassVars
-  end
-
-  # Accepts a block which uses the {dry-validation DSL}[http://dry-rb.org/gems/dry-validation/]
-  # to validate the 'fields' object of a content type.
-  def validate_fields(&block)
-    raise ArgumentError, 'validate_fields requires a block' unless block_given?
-
-    dsl = ProcDsl.new(Proc.new(&block))
-
-    ct = try(:content_type) || name.demodulize.camelize(:lower)
-    (validations[ct] ||= []) << dsl
-  end
-
-  # Validates a single field is of the expected type.
-  # Type expectations are one of:
-  #
-  # [:String]   the field type must be `Symbol` or `Text`
-  # [:Int]      the field type must be `Integer`
-  # [:Float]    the field type must be `Number`
-  # [:DateTime] the field type must be 'Date'
-  # [:Asset]    the field must be a link and the `linkType` must be `Asset`
-  # [:Link]     the field must be a link and the `linkType` must be `Entry`.
-  # [:Location] the field type must be `Location`
-  # [:Boolean]  the field type must be `Boolean`
-  # [:Json]     the field type must be `Json` - a json blob.
-  # [:Array]    the field must be a List.
-  #
-  # Additional validation options can be enforced:
-  #
-  # [:required] the 'Required Field' checkbox must be checked
-  # [:optional] the 'Required Field' checkbox must not be checked
-  # [:link_to]  (only `:Link` or `:Array` type) the given content type(s) must be
-  #             checked in the 'Accept only specified entry type' validations
-  #             Example:
-  #               validate_field :button, :Link, link_to: ['button', 'altButton']
-  #
-  # [:items]    (only `:Array` type) the items of the list must be of the given type.
-  #             Example:
-  #               validate_field :my_strings, :Array, items: :String
-  #
-  # Examples:
-  # see WCC::Contentful::Model::Menu and WCC::Contentful::Model::MenuButton
-  def validate_field(field, type, *options)
-    dsl = FieldDsl.new(field, type, options)
-
-    ct = try(:content_type) || name.demodulize.camelize(:lower)
-    (validations[ct] ||= []) << dsl
-  end
-
-  def no_validate_field(field)
-    ct = try(:content_type) || name.demodulize.camelize(:lower)
-    return unless v = validations[ct]
-
-    field = field.to_s.camelize(:lower) unless field.is_a?(String)
-    v.reject! { |dsl| dsl.try(:field) == field }
-  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

@@ -1,166 +0,0 @@
-# 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/http_adapter.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-gem 'http'
-require 'http'
-
-class HttpAdapter
-  def call(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
-
-  def post(url, body, headers = {}, proxy = {})
-    if proxy[:host]
-      HTTP[headers].via(proxy[:host], proxy[:port], proxy[:username], proxy[:password])
-        .post(url, json: body)
-    else
-      HTTP[headers].post(url, json: body)
-    end
-  end
-end

data/lib/wcc/contentful/store/lazy_cache_store.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module WCC::Contentful::Store
-  class LazyCacheStore
-    def initialize(client, cache: nil)
-      @cdn = CDNAdapter.new(client)
-      @cache = cache || ActiveSupport::Cache::MemoryStore.new
-      @client = client
-    end
-
-    def find(key, **options)
-      found =
-        @cache.fetch(key) do
-          # if it's not a contentful ID don't hit the API.
-          # Store a nil object if we can't find the object on the CDN.
-          (@cdn.find(key, options) || nil_obj(key)) if key =~ /^\w+$/
-        end
-
-      case found.try(:dig, 'sys', 'type')
-      when 'Nil', 'DeletedEntry', 'DeletedAsset'
-        nil
-      else
-        found
-      end
-    end
-
-    # TODO: https://github.com/watermarkchurch/wcc-contentful/issues/18
-    #  figure out how to cache the results of a find_by query, ex:
-    #  `find_by('slug' => '/about')`
-    def find_by(content_type:, filter: nil, options: nil)
-      if filter.keys == ['sys.id']
-        # Direct ID lookup, like what we do in `WCC::Contentful::ModelMethods.resolve`
-        # We can return just this item.  Stores are not required to implement :include option.
-        if found = @cache.read(filter['sys.id'])
-          return found
-        end
-      end
-
-      q = find_all(content_type: content_type, options: { limit: 1 }.merge!(options || {}))
-      q = q.apply(filter) if filter
-      q.first
-    end
-
-    def find_all(content_type:, options: nil)
-      Query.new(
-        store: self,
-        client: @client,
-        relation: { content_type: content_type },
-        cache: @cache,
-        options: options
-      )
-    end
-
-    # #index is called whenever the sync API comes back with more data.
-    def index(json)
-      id = json.dig('sys', 'id')
-      return unless prev = @cache.read(id)
-
-      if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision'))
-        return prev if next_rev < prev_rev
-      end
-
-      # we also set deletes in the cache - no need to go hit the API when we know
-      # this is a nil object
-      ensure_hash json
-      @cache.write(id, json)
-
-      case json.dig('sys', 'type')
-      when 'DeletedEntry', 'DeletedAsset'
-        nil
-      else
-        json
-      end
-    end
-
-    def set(key, value)
-      ensure_hash value
-      old = @cache.read(key)
-      @cache.write(key, value)
-      old
-    end
-
-    def delete(key)
-      old = @cache.read(key)
-      @cache.delete(key)
-      old
-    end
-
-    def nil_obj(id)
-      {
-        'sys' => {
-          'id' => id,
-          'type' => 'Nil',
-          'revision' => 1
-        }
-      }
-    end
-
-    def ensure_hash(val)
-      raise ArgumentError, 'Value must be a Hash' unless val.is_a?(Hash)
-    end
-
-    class Query < CDNAdapter::Query
-      def initialize(cache:, **extra)
-        super(cache: cache, **extra)
-        @cache = cache
-      end
-
-      private
-
-      def response
-        # Disabling because the superclass already took `@response`
-        # rubocop:disable Naming/MemoizedInstanceVariableName
-        @wrapped_response ||= ResponseWrapper.new(super, @cache)
-        # rubocop:enable Naming/MemoizedInstanceVariableName
-      end
-
-      ResponseWrapper =
-        Struct.new(:response, :cache) do
-          delegate :count, to: :response
-
-          def items
-            @items ||=
-              response.items.map do |item|
-                id = item.dig('sys', 'id')
-                prev = cache.read(id)
-                unless (prev_rev = prev&.dig('sys', 'revision')) &&
-                    (next_rev = item.dig('sys', 'revision')) &&
-                    next_rev < prev_rev
-
-                  cache.write(id, item)
-                end
-
-                item
-              end
-          end
-
-          def includes
-            @includes ||= IncludesWrapper.new(response, cache)
-          end
-        end
-
-      IncludesWrapper =
-        Struct.new(:response, :cache) do
-          def [](id)
-            return unless item = response.includes[id]
-
-            prev = cache.read(id)
-            unless (prev_rev = prev&.dig('sys', 'revision')) &&
-                (next_rev = item.dig('sys', 'revision')) &&
-                next_rev < prev_rev
-
-              cache.write(id, item)
-            end
-
-            item
-          end
-        end
-    end
-  end
-end