wcc-contentful 0.4.0.pre.rc → 1.0.0.pre.rc1

data/Gemfile

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in wcc-contentful.gemspec
-gemspec

data/app/jobs/wcc/contentful/delayed_sync_job.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_job'
-
-module WCC::Contentful
-  # This job uses the Contentful Sync API to update the configured store with
-  # the latest data from Contentful.
-  class DelayedSyncJob < ActiveJob::Base
-    include WCC::Contentful::ServiceAccessors
-
-    self.queue_adapter = :async
-    queue_as :default
-
-    def self.mutex
-      @mutex ||= Mutex.new
-    end
-
-    def perform(event = nil)
-      up_to_id = nil
-      up_to_id = event[:up_to_id] || event.dig('sys', 'id') if event
-      sync!(up_to_id: up_to_id)
-    end
-
-    # Calls the Contentful Sync API and updates the configured store with the returned
-    # data.
-    #
-    # @param [String] 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 sync!(up_to_id: nil)
-      return unless store.respond_to?(:index)
-
-      self.class.mutex.synchronize do
-        next_sync_token = store.find('sync:token')&.fetch('token')
-        sync_resp = client.sync(sync_token: next_sync_token)
-
-        id_found = up_to_id.nil?
-
-        count = 0
-        sync_resp.items.each do |item|
-          id = item.dig('sys', 'id')
-          id_found ||= id == up_to_id
-          store.index(item)
-          count += 1
-        end
-        store.set('sync:token', token: sync_resp.next_sync_token)
-
-        logger.info "Synced #{count} entries.  Next sync token:\n  #{sync_resp.next_sync_token}"
-        sync_later!(up_to_id: up_to_id) unless id_found
-        sync_resp.next_sync_token
-      end
-    end
-
-    # Drops an ActiveJob job to invoke WCC::Contentful.sync! after a given amount
-    # of time.
-    def sync_later!(up_to_id: nil, wait: 10.minutes)
-      WCC::Contentful::DelayedSyncJob.set(wait: wait)
-        .perform_later(up_to_id: up_to_id)
-    end
-  end
-end

data/lib/wcc/contentful/client_ext.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-class Contentful::Client
-  class << self
-    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 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/graphql.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-gem 'graphql', '~> 1.7'
-require 'graphql'
-
-module WCC::Contentful
-  # This module builds a GraphQL schema out of our IndexedRepresentation.
-  # It is currently unused and not hooked up in the WCC::Contentful.init! method.
-  # TODO: https://zube.io/watermarkchurch/development/c/2234 hook it up
-  module Graphql
-  end
-end
-
-require_relative 'graphql/builder'

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

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphql'
-
-require_relative 'types'
-
-module WCC::Contentful::Graphql
-  class Builder
-    attr_reader :schema_types
-
-    def initialize(types, store)
-      @types = types
-      @store = store
-    end
-
-    def build_schema
-      @schema_types = build_schema_types
-
-      root_query_type = build_root_query(@schema_types)
-
-      builder = self
-      GraphQL::Schema.define do
-        query root_query_type
-
-        resolve_type ->(_type, obj, _ctx) {
-          content_type = WCC::Contentful::Helpers.content_type_from_raw(obj)
-          builder.schema_types[content_type]
-        }
-      end
-    end
-
-    private
-
-    def build_root_query(schema_types)
-      store = @store
-
-      GraphQL::ObjectType.define do
-        name 'Query'
-        description 'The query root of this schema'
-
-        schema_types.each do |content_type, schema_type|
-          field schema_type.name.to_sym do
-            type schema_type
-            argument :id, types.ID
-            description "Find a #{schema_type.name} by ID"
-
-            resolve ->(_obj, args, _ctx) {
-              if args['id'].nil?
-                store.find_by(content_type: content_type)
-              else
-                store.find(args['id'])
-              end
-            }
-          end
-
-          field "all#{schema_type.name}".to_sym do
-            type schema_type.to_list_type
-            argument :filter, Types::FilterType
-
-            resolve ->(_obj, args, ctx) {
-              relation = store.find_all(content_type: content_type)
-              # TODO: improve this POC
-              if args[:filter]
-                filter = {}
-                filter[args[:filter]['field']] = { eq: args[:filter][:eq] }
-                relation = relation.apply(filter, ctx)
-              end
-              relation.result
-            }
-          end
-        end
-      end
-    end
-
-    def build_schema_types
-      @types.each_with_object({}) do |(k, v), h|
-        h[k] = build_schema_type(v)
-      end
-    end
-
-    def build_schema_type(typedef)
-      store = @store
-      builder = self
-      content_type = typedef.content_type
-
-      GraphQL::ObjectType.define do
-        name(typedef.name)
-
-        description("Generated from content type #{content_type}")
-
-        field :id, !types.ID do
-          resolve ->(obj, _args, _ctx) {
-            obj.dig('sys', 'id')
-          }
-        end
-
-        field :_content_type, !types.String do
-          resolve ->(_, _, _) {
-            content_type
-          }
-        end
-
-        # Make a field for each column:
-        typedef.fields.each_value do |f|
-          case f.type
-          when :Asset
-            field(f.name.to_sym, -> {
-              type = builder.schema_types['Asset']
-              type = type.to_list_type if f.array
-              type
-            }) do
-              resolve ->(obj, _args, ctx) {
-                links = obj.dig('fields', f.name, ctx[:locale] || 'en-US')
-                return if links.nil?
-
-                if links.is_a? Array
-                  links.reject(&:nil?).map { |l| store.find(l.dig('sys', 'id')) }
-                else
-                  store.find(links.dig('sys', 'id'))
-                end
-              }
-            end
-          when :Link
-            field(f.name.to_sym, -> {
-              type =
-                if f.link_types.nil? || f.link_types.empty?
-                  builder.schema_types['AnyContentful'] ||=
-                    Types::BuildUnionType.call(builder.schema_types, 'AnyContentful')
-                elsif f.link_types.length == 1
-                  builder.schema_types[f.link_types.first]
-                else
-                  from_types = builder.schema_types.select { |key| f.link_types.include?(key) }
-                  name = "#{typedef.name}_#{f.name}"
-                  builder.schema_types[name] ||= Types::BuildUnionType.call(from_types, name)
-                end
-              type = type.to_list_type if f.array
-              type
-            }) do
-              resolve ->(obj, _args, ctx) {
-                links = obj.dig('fields', f.name, ctx[:locale] || 'en-US')
-                return if links.nil?
-
-                if links.is_a? Array
-                  links.reject(&:nil?).map { |l| store.find(l.dig('sys', 'id')) }
-                else
-                  store.find(links.dig('sys', 'id'))
-                end
-              }
-            end
-          else
-            type =
-              case f.type
-              when :DateTime
-                Types::DateTimeType
-              when :Coordinates
-                Types::CoordinatesType
-              when :Json
-                Types::HashType
-              else
-                types.public_send(f.type)
-              end
-            type = type.to_list_type if f.array
-            field(f.name.to_sym, type) do
-              resolve ->(obj, _args, ctx) {
-                if obj.is_a? Array
-                  obj.map { |o| o.dig('fields', f.name, ctx[:locale] || 'en-US') }
-                else
-                  obj.dig('fields', f.name, ctx[:locale] || 'en-US')
-                end
-              }
-            end
-          end
-        end
-      end
-    end
-  end
-end

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/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