wcc-contentful 0.0.3 → 0.1.0

data/lib/wcc/contentful/exceptions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module WCC::Contentful
+  class ValidationError < StandardError
+    Message =
+      Struct.new(:path, :error) do
+        def to_s
+          "#{path}: #{error}"
+        end
+      end
+
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = ValidationError.join_msg_keys(errors)
+      super("Content Type Schema from Contentful failed validation!\n  #{@errors.join("\n  ")}")
+    end
+
+    # 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)
+    end
+  end
+end

data/lib/wcc/contentful/graphql.rb

@@ -0,0 +1,15 @@
+
+# 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

@@ -0,0 +1,172 @@
+# 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).first
+              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_by(content_type: content_type)
+              relation = relation.apply(args[:filter], ctx) if args[:filter]
+              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

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

@@ -0,0 +1,28 @@
+
+# frozen_string_literal: true
+
+module WCC::Contentful::Helpers
+  extend self
+
+  def content_type_from_raw(value)
+    case value.dig('sys', 'type')
+    when 'Entry'
+      value.dig('sys', 'contentType', 'sys', 'id')
+    when 'Asset'
+      'Asset'
+    else
+      raise ArgumentError, "Unknown content type '#{value.dig('sys', 'type') || 'null'}'"
+    end
+  end
+
+  def constant_from_content_type(content_type)
+    content_type.camelize.gsub(/[^_a-zA-Z0-9]/, '_')
+  end
+
+  def shared_prefix(string_array)
+    string_array.reduce do |l, s|
+      l = l.chop while l != s[0...l.length]
+      l
+    end
+  end
+end

data/lib/wcc/contentful/indexed_representation.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module WCC::Contentful
+  # The result of running the indexer on raw content types to produce
+  # a type definition which can be used to build models or graphql types.
+  class IndexedRepresentation
+    def initialize(types = {})
+      @types = types
+    end
+
+    delegate :keys, to: :@types
+    delegate :[], to: :@types
+    delegate :each_with_object, to: :@types
+    delegate :each_value, to: :@types
+
+    def []=(id, value)
+      raise ArgumentError unless value.is_a?(ContentType)
+      @types[id] = value
+    end
+
+    def self.from_json(hash)
+      hash = JSON.parse(hash) if hash.is_a?(String)
+
+      ret = IndexedRepresentation.new
+      hash.each do |id, content_type_hash|
+        ret[id] = ContentType.new(content_type_hash)
+      end
+      ret
+    end
+
+    def to_json
+      @types.to_json
+    end
+
+    class ContentType
+      ATTRIBUTES = %i[
+        name
+        content_type
+        fields
+      ].freeze
+
+      attr_accessor(*ATTRIBUTES)
+
+      def initialize(hash_or_id = nil)
+        @fields = {}
+        return unless hash_or_id
+        if hash_or_id.is_a?(String)
+          @name = hash_or_id
+          return
+        end
+
+        if raw_fields = (hash_or_id.delete('fields') || hash_or_id.delete(:fields))
+          raw_fields.each do |field_name, raw_field|
+            @fields[field_name] = Field.new(raw_field)
+          end
+        end
+
+        hash_or_id.each { |k, v| public_send("#{k}=", v) }
+      end
+    end
+
+    class Field
+      ATTRIBUTES = %i[
+        name
+        type
+        array
+        required
+        link_types
+      ].freeze
+
+      attr_accessor(*ATTRIBUTES)
+
+      TYPES = %i[
+        String
+        Int
+        Float
+        DateTime
+        Boolean
+        Json
+        Coordinates
+        Link
+        Asset
+      ].freeze
+
+      def type=(raw_type)
+        unless TYPES.include?(raw_type)
+          raise ArgumentError, "Unknown type #{raw_type}, expected one of: #{TYPES}"
+        end
+        @type = raw_type
+      end
+
+      def initialize(hash_or_id = nil)
+        return unless hash_or_id
+        if hash_or_id.is_a?(String)
+          @name = hash_or_id
+          return
+        end
+
+        if raw_type = hash_or_id.delete('type')
+          raw_type = raw_type.to_sym
+          unless TYPES.include?(raw_type)
+            raise ArgumentError, "Unknown type #{raw_type}, expected one of: #{TYPES}"
+          end
+          @type = raw_type
+        end
+
+        hash_or_id.each { |k, v| public_send("#{k}=", v) }
+      end
+    end
+  end
+end

data/lib/wcc/contentful/model.rb

@@ -0,0 +1,24 @@
+
+# frozen_string_literal: true
+
+class WCC::Contentful::Model
+  extend WCC::Contentful::Helpers
+  extend WCC::Contentful::ModelValidators
+
+  class << self
+    attr_accessor :store
+  end
+
+  def self.all_models
+    WCC::Contentful::Model.constants(false).map { |k| WCC::Contentful::Model.const_get(k) }
+  end
+
+  def self.find(id, context = nil)
+    return unless raw = store.find(id)
+
+    content_type = content_type_from_raw(raw)
+
+    const = WCC::Contentful::Model.const_get(constant_from_content_type(content_type))
+    const.new(raw, context)
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class WCC::Contentful::Model::Menu < WCC::Contentful::Model
+  validate_field :name, :String
+  validate_field :top_button, :Link, :optional, link_to: 'menuButton'
+  validate_field :items, :Array, link_to: %w[menu menuButton]
+end