wcc-contentful 0.0.3 → 0.1.0

data/lib/wcc/contentful/simple_client/response.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+class WCC::Contentful::SimpleClient
+  class Response
+    attr_reader :raw_response
+    attr_reader :client
+    attr_reader :request
+
+    delegate :code, to: :raw_response
+    delegate :headers, to: :raw_response
+
+    def body
+      @body ||= raw_response.body.to_s
+    end
+
+    def raw
+      @raw ||= JSON.parse(body)
+    end
+    alias_method :to_json, :raw
+
+    def error_message
+      raw.dig('message') || "#{code}: #{raw_response.message}"
+    end
+
+    def initialize(client, request, raw_response)
+      @client = client
+      @request = request
+      @raw_response = raw_response
+      @body = raw_response.body.to_s
+    end
+
+    def assert_ok!
+      return self if code >= 200 && code < 300
+      raise ApiError[code], self
+    end
+
+    def each_page(&block)
+      raise ArgumentError, 'Not a collection response' unless raw['items']
+
+      memoized_pages = (@memoized_pages ||= [self])
+      ret =
+        Enumerator.new do |y|
+          page_index = 0
+          current_page = self
+          loop do
+            y << current_page
+
+            skip_amt = current_page.raw['items'].length + current_page.raw['skip']
+            break if current_page.raw['items'].empty? || skip_amt >= current_page.raw['total']
+
+            page_index += 1
+            if page_index < memoized_pages.length
+              current_page = memoized_pages[page_index]
+            else
+              current_page = @client.get(
+                @request[:url],
+                (@request[:query] || {}).merge({ skip: skip_amt })
+              )
+              current_page.assert_ok!
+              memoized_pages.push(current_page)
+            end
+          end
+        end
+
+      if block_given?
+        ret.map(&block)
+      else
+        ret.lazy
+      end
+    end
+
+    def items
+      each_page.flat_map do |page|
+        page.raw['items']
+      end
+    end
+
+    def count
+      raw['total']
+    end
+
+    def first
+      raise ArgumentError, 'Not a collection response' unless raw['items']
+      raw['items'].first
+    end
+  end
+
+  class SyncResponse < Response
+    def initialize(response)
+      super(response.client, response.request, response.raw_response)
+    end
+
+    def next_sync_token
+      @next_sync_token ||= SyncResponse.parse_sync_token(raw['nextSyncUrl'])
+    end
+
+    def each_page
+      raise ArgumentError, 'Not a collection response' unless raw['items']
+
+      memoized_pages = (@memoized_pages ||= [self])
+      ret =
+        Enumerator.new do |y|
+          page_index = 0
+          current_page = self
+          loop do
+            y << current_page
+
+            break if current_page.raw['items'].empty?
+
+            page_index += 1
+            if page_index < memoized_pages.length
+              current_page = memoized_pages[page_index]
+            else
+              current_page = @client.get(raw['nextSyncUrl'])
+              current_page.assert_ok!
+              @next_sync_token = SyncResponse.parse_sync_token(current_page.raw['nextSyncUrl'])
+              memoized_pages.push(current_page)
+            end
+          end
+        end
+
+      if block_given?
+        ret.map(&block)
+      else
+        ret.lazy
+      end
+    end
+
+    def count
+      raw['items'].length
+    end
+
+    def self.parse_sync_token(url)
+      url = URI.parse(url)
+      q = CGI.parse(url.query)
+      q['sync_token']&.first
+    end
+  end
+
+  class ApiError < StandardError
+    attr_reader :response
+
+    def self.[](code)
+      case code
+      when 404
+        NotFoundError
+      else
+        ApiError
+      end
+    end
+
+    def initialize(response)
+      @response = response
+      super(response.error_message)
+    end
+  end
+
+  class NotFoundError < ApiError
+  end
+end

data/lib/wcc/contentful/store.rb

@@ -0,0 +1,8 @@
+
+# frozen_string_literal: true
+
+require_relative 'store/memory_store'
+require_relative 'store/cdn_adapter'
+
+# required dynamically if they select the 'postgres' store option
+# require_relative 'store/postgres_store'

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Store
+  class CDNAdapter
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def find(key)
+      entry =
+        begin
+          client.entry(key, locale: '*')
+        rescue WCC::Contentful::SimpleClient::NotFoundError
+          client.asset(key, locale: '*')
+        end
+      entry&.raw
+    end
+
+    def find_all
+      raise ArgumentError, 'use find_by content type instead'
+    end
+
+    def find_by(content_type:)
+      Query.new(@client, content_type: content_type)
+    end
+
+    class Query
+      delegate :count, to: :resolve
+
+      def first
+        resolve.items.first
+      end
+
+      def map(&block)
+        resolve.items.map(&block)
+      end
+
+      def result
+        raise ArgumentError, 'Not Implemented'
+      end
+
+      def initialize(client, relation)
+        raise ArgumentError, 'Client cannot be nil' unless client.present?
+        raise ArgumentError, 'content_type must be provided' unless relation[:content_type].present?
+        @client = client
+        @relation = relation
+      end
+
+      def apply(filter, context = nil)
+        return eq(filter[:field], filter[:eq], context) if filter[:eq]
+
+        raise ArgumentError, "Filter not implemented: #{filter}"
+      end
+
+      def eq(field, expected, context = nil)
+        locale = context[:locale] if context.present?
+        locale ||= 'en-US'
+        Query.new(@client,
+          @relation.merge("fields.#{field}.#{locale}" => expected))
+      end
+
+      private
+
+      def resolve
+        return @resolve if @resolve
+        @resolve ||=
+          if @relation[:content_type] == 'Asset'
+            @client.assets(
+              { locale: '*' }.merge!(@relation.reject { |k| k == :content_type })
+            )
+          else
+            @client.entries({ locale: '*' }.merge!(@relation))
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Store
+  class MemoryStore
+    def initialize
+      @hash = {}
+      @mutex = Mutex.new
+    end
+
+    def index(key, value)
+      value = value.deep_dup.freeze
+      @mutex.synchronize do
+        @hash[key] = value
+      end
+    end
+
+    def keys
+      @mutex.synchronize { @hash.keys }
+    end
+
+    def find(key)
+      @mutex.synchronize do
+        @hash[key]
+      end
+    end
+
+    def find_all
+      Query.new(@mutex.synchronize { @hash.values })
+    end
+
+    def find_by(content_type:)
+      relation = @mutex.synchronize { @hash.values }
+
+      relation =
+        relation.reject do |v|
+          value_content_type = v.dig('sys', 'contentType', 'sys', 'id')
+          value_content_type.nil? || value_content_type != content_type
+        end
+      Query.new(relation)
+    end
+
+    class Query
+      delegate :first, to: :@relation
+      delegate :map, to: :@relation
+      delegate :count, to: :@relation
+
+      def result
+        @relation.dup
+      end
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def apply(filter, context = nil)
+        return eq(filter[:field], filter[:eq], context) if filter[:eq]
+
+        raise ArgumentError, "Filter not implemented: #{filter}"
+      end
+
+      def eq(field, expected, context = nil)
+        locale = context[:locale] if context.present?
+        locale ||= 'en-US'
+        Query.new(@relation.select do |v|
+          val = v.dig('fields', field, locale)
+          if val.is_a? Array
+            val.include?(expected)
+          else
+            val == expected
+          end
+        end)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+gem 'pg', '~> 1.0'
+require 'pg'
+
+module WCC::Contentful::Store
+  class PostgresStore
+    def initialize(connection_options = nil)
+      connection_options ||= { dbname: 'postgres' }
+      @conn = PG.connect(connection_options)
+      PostgresStore.ensure_schema(@conn)
+    end
+
+    def index(key, value)
+      @conn.exec_prepared('index_entry', [key, value.to_json])
+      true
+    end
+
+    def keys
+      result = @conn.exec_prepared('select_ids')
+      arr = []
+      result.each { |r| arr << r['id'].strip }
+      arr
+    end
+
+    def find(key)
+      result = @conn.exec_prepared('select_entry', [key])
+      return if result.num_tuples == 0
+      JSON.parse(result.getvalue(0, 1))
+    end
+
+    def find_all
+      Query.new(@conn)
+    end
+
+    def find_by(content_type:)
+      statement = "WHERE data->'sys'->'contentType'->'sys'->>'id' = $1"
+      Query.new(
+        @conn,
+        statement,
+        [content_type]
+      )
+    end
+
+    class Query
+      def initialize(conn, statement = nil, params = nil)
+        @conn = conn
+        @statement = statement ||
+          "WHERE data->'sys'->>'id' IS NOT NULL"
+        @params = params || []
+      end
+
+      def apply(filter, context = nil)
+        return eq(filter[:field], filter[:eq], context) if filter[:eq]
+
+        raise ArgumentError, "Filter not implemented: #{filter}"
+      end
+
+      def eq(field, expected, context = nil)
+        locale = context[:locale] if context.present?
+        locale ||= 'en-US'
+
+        params = @params.dup
+
+        statement = @statement + " AND data->'fields'->$#{push_param(field, params)}" \
+          "->$#{push_param(locale, params)} ? $#{push_param(expected, params)}"
+
+        Query.new(
+          @conn,
+          statement,
+          params
+        )
+      end
+
+      def count
+        return @count if @count
+        statement = 'SELECT count(*) FROM contentful_raw ' + @statement
+        result = @conn.exec(statement, @params)
+        @count = result.getvalue(0, 0).to_i
+      end
+
+      def first
+        return @first if @first
+        statement = 'SELECT * FROM contentful_raw ' + @statement + ' LIMIT 1'
+        result = @conn.exec(statement, @params)
+        JSON.parse(result.getvalue(0, 1))
+      end
+
+      def map
+        arr = []
+        resolve.each { |row| arr << yield(JSON.parse(row['data'])) }
+        arr
+      end
+
+      def result
+        arr = []
+        resolve.each { |row| arr << JSON.parse(row['data']) }
+        arr
+      end
+
+      private
+
+      def resolve
+        return @resolved if @resolved
+        statement = 'SELECT * FROM contentful_raw ' + @statement
+        @resolved = @conn.exec(statement, @params)
+      end
+
+      def push_param(param, params)
+        params << param
+        params.length
+      end
+    end
+
+    def self.ensure_schema(conn)
+      conn.exec(<<~HEREDOC
+        CREATE TABLE IF NOT EXISTS contentful_raw (
+          id char(22) PRIMARY KEY,
+          data jsonb
+        );
+        CREATE INDEX IF NOT EXISTS contentful_raw_value_type ON contentful_raw ((data->'sys'->>'type'));
+        CREATE INDEX IF NOT EXISTS contentful_raw_value_content_type ON contentful_raw ((data->'sys'->'contentType'->'sys'->>'id'));
+HEREDOC
+      )
+
+      conn.prepare('index_entry', 'INSERT INTO contentful_raw (id, data) values ($1, $2) ' \
+        'ON CONFLICT (id) DO UPDATE SET data = $2')
+      conn.prepare('select_entry', 'SELECT * FROM contentful_raw WHERE id = $1')
+      conn.prepare('select_ids', 'SELECT id FROM contentful_raw')
+    end
+  end
+end