wcc-contentful 1.3.2 → 1.4.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cbb012e1545d674abc930f6513ea342611beb586b2afe5ad5ce703903e5a9cb
-  data.tar.gz: da23bc050241c0ae55e1952fc48d892d2b2d768f33d314aef34f4a5f159db585
+  metadata.gz: 0b1a0aa21bc1bc749fdfc169eecf55d5bf829e0d4ac4272e90649c2d46abf622
+  data.tar.gz: 12812d6728c4992ea3763cdbe0dc8f204267a75c3f35a052a663ec8c4f380115
 SHA512:
-  metadata.gz: e53a8c32ea3687f8e5e8bfaac3a4a15d940e21873c7068c20b26cca92b5ed2876a8f680949f2bf169ebae258a00c0665f63c314888a1c3379b69b37da2be97d5
-  data.tar.gz: 24e358dc0f8ec03873ffb27ff6d79c5a64f0fda24b5f66336482ca38f0b4b654227907df96955005fcc4cf04ed811e78070c3688f3c3d0629406666734c8fd93
+  metadata.gz: 9226778b6abf97db358f836ed0659e202f13266fbf946acd793cbeed23f69cb3cab475e9750ca64761ba6ceecd38cdaaad7f919ea2a2d04f00fa4d8e940d9653
+  data.tar.gz: c4f0bb1b6e44fa8b0a4aa647e246ff7dd6726d62e2905d026f2bb201867fb09af640b266ab95c22e04dab6b23f4c162ec6d88cf3bd45ca41c9a5853eb4842d80

data/README.md

@@ -32,7 +32,7 @@ Table of Contents:
 
 ## Why did you rewrite the Contentful ruby stack?
 
-We started working with Contentful almost 3 years ago.  Since that time, Contentful's ruby stack has improved, but there are still a number of pain points that we feel we have addressed better with our gem.  These are:
+We started working with Contentful almost 5 years ago.  Since that time, Contentful's ruby stack has improved, but there are still a number of pain points that we feel we have addressed better with our gem.  These are:
 
 * [Low-level caching](#low-level-caching)
 * [Better integration with Rails & Rails models](#better-rails-integration)
@@ -160,22 +160,34 @@ The following examples show how to use this API to find entries of the `page`
 content type:
 
 ```ruby
+# app/models/page.rb
+class Page < WCC::Contentful::Model::Page
+
+  # You can add additional methods here
+end
+
 # Find objects by id
-WCC::Contentful::Model::Page.find('1E2ucWSdacxxf233sfa3')
-# => #<WCC::Contentful::Model::Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>
+Page.find('1E2ucWSdacxxf233sfa3')
+# => #<Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>
 
 # Find objects by field
-WCC::Contentful::Model::Page.find_by(slug: '/some-slug')
-# => #<WCC::Contentful::Model::Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>
+Page.find_by(slug: '/some-slug')
+# => #<Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>
 
 # Use operators to filter by a field
 # must use full notation for sys attributes (except ID)
-WCC::Contentful::Model::Page.find_all('sys.created_at' => { lte: Date.today })
-# => [#<WCC::Contentful::Model::Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>, ... ]
+Page.find_all('sys.created_at' => { lte: Date.today })
+# => [#<Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>, ... ]
 
 # Nest queries to mimick joins
-WCC::Contentful::Model::Page.find_by(subpages: { slug: '/some-slug' })
-# => #<WCC::Contentful::Model::Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>
+Page.find_by(subpages: { slug: '/some-slug' })
+# => #<Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>
+
+# Fetch an entry in a different locale
+spanish_homepage = Page.find_by(slug: '/', options: { locale: 'es-US' })
+# => #<Page:0x0000000005c71a78 @created_at=2018-04-16 18:41:17 UTC...>
+spanish_homepage.title
+# => Esta es la página principal
 
 # Pass the preview flag to use the preview client (must have set preview_token config param)
 preview_redirect = WCC::Contentful::Model::Redirect.find_by({ slug: 'draft-redirect' }, preview: true)
@@ -224,6 +236,18 @@ query.result.force
 # => [{"sys"=> ...}, {"sys"=> ...}, ...]
 ```
 
+The store layer, while superficially similar to the Contentful API, tries to present a different "View" over the data
+which is more compatible with the Model layer.  It resolves includes by actually replacing the in-memory `Link` objects
+with their linked `Entry` representations.  This lets you traverse the links naturally using `#dig` or `#[]`:
+
+```ruby
+# Include to a depth of 3 to make sure it's included
+homepage = store.find_by(slug: '/', include: 3)
+# Traverse through the top nav menu => menu button 0 => about page
+about_page = homepage.dig('fields', 'nav_menu', 'fields', 'buttons', 0, 'fields', 'page')
+```
+
+
 See the {WCC::Contentful::Store} documentation for more details.
 
 ### Direct CDN API (SimpleClient)
@@ -350,7 +374,6 @@ WCC::Contentful::SimpleClient::Cdn.new(
   space: '1234',
   # optional
   environment: 'staging', # omit to use master
-  default_locale: '*',
   rate_limit_wait_timeout: 10,
   instrumentation: ActiveSupport::Notifications,
   connection: Faraday.new { |builder| ... },
@@ -394,10 +417,35 @@ newest version of an entry, or delete an entry out of the hash.
 #### Store Middleware
 
 The store layer is made up of a base store (which implements {WCC::Contentful::Store::Interface}),
-and optional middleware.  The middleware
-allows custom transformation of received entries via the `#select` and `#transform`
-methods.  To create your own middleware simply include {WCC::Contentful::Middleware::Store}
-and implement those methods, then call `use` when configuring the store:
+and some required middleware.  The list of default middleware applied to each store is found in
+{WCC::Contentful::Store::Factory.default_middleware}
+
+To create your own middleware simply include {WCC::Contentful::Middleware::Store}.  Then you can optionally implement
+the `#transform` and `#select?` methods:
+
+```ruby
+class MyMiddleware
+  include WCC::Contentful::Middleware::Store
+
+  # Called for each entry that is requested out of the backing store.  You can modify the entry and return it to the
+  # next layer.
+  def transform(entry, options)
+    # Do something with the entry...
+    # Make sure you return it at the end!
+    entry
+  end
+
+  def select?(entry, options)
+    # Choose whether this entry should exist or not.  If you return false here, then the entry will act as though it
+    # were archived in Contentful.
+    entry.dig('fields', 'hide_until') > Time.zone.now
+  end
+end
+```
+
+You can also override any of the standard Store methods.
+
+To apply the middleware, call `use` when configuring the store:
 
 ```ruby
 config.store :direct do
@@ -415,6 +463,24 @@ ActiveModel.  The models are namespaced under the root class {WCC::Contentful::M
 Each model's implementation of `.find`, `.find_by`, and `.find_all` simply call
 into the configured Store.
 
+Models can be initialized directly with the `.new` method, by passing in a hash:
+```ruby
+entry = { 'sys' => ..., 'fields' => ... }
+Page.new(entry)
+```
+
+**The initializer must receive a localized entry**.  An entry found using a `locale=*` query
+must be transformed to a localized entry using the {WCC::Contentful::EntryLocaleTransformer} before
+passing it to your model:
+
+```ruby
+entry = client.entry('1234', locale: '*').raw
+localized_entry = WCC::Contentful::EntryLocaleTransformer.transform_to_locale(entry, 'en-US')
+Page.new(localized_entry)
+```
+
+The Store layer ensures that localized entries are returned using the {WCC::Contentful::Middleware::Store::LocaleMiddleware}.
+
 The main benefit of the Model layer is lazy link resolution.  When a model's
 property is accessed, if that property is a link that has not been resolved
 yet (for example using the `include: n` parameter on `.find_by`), the model

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

@@ -51,7 +51,6 @@ module WCC::Contentful
         management_token: config.management_token,
         space: config.space,
         environment: config.environment,
-        default_locale: config.default_locale,
         connection: config.connection,
         webhook_username: config.webhook_username,
         webhook_password: config.webhook_password,

data/lib/wcc/contentful/configuration.rb

@@ -8,6 +8,7 @@ class WCC::Contentful::Configuration
     connection
     connection_options
     default_locale
+    locale_fallbacks
     environment
     instrumentation_adapter
     logger
@@ -40,6 +41,11 @@ class WCC::Contentful::Configuration
   attr_accessor :environment
   # Sets the default locale.  Defaults to 'en-US'.
   attr_accessor :default_locale
+  # Sets up locale fallbacks.  This is a Ruby hash which maps locale codes to fallback locale codes.
+  # Defaults are loaded from contentful-schema.json but can be overridden here.
+  # If data is missing for one locale, we will use data in the "fallback locale".
+  # See https://www.contentful.com/developers/docs/tutorials/general/setting-locales/#custom-fallback-locales
+  attr_accessor :locale_fallbacks
   # Sets the Content Preview API access token.  Only required if you use the
   # preview flag.
   attr_accessor :preview_token
@@ -106,11 +112,11 @@ class WCC::Contentful::Configuration
   #           The block is executed in the context of a WCC::Contentful::Store::Factory.
   #           this can be used to apply middleware, etc.
   def store(*params, &block)
-    type, *params = params
-    if type
+    preset, *params = params
+    if preset
       @store_factory = WCC::Contentful::Store::Factory.new(
         self,
-        type,
+        preset,
         params
       )
     end
@@ -199,7 +205,8 @@ class WCC::Contentful::Configuration
     @management_token = ENV.fetch('CONTENTFUL_MANAGEMENT_TOKEN', nil)
     @preview_token = ENV.fetch('CONTENTFUL_PREVIEW_TOKEN', nil)
     @space = ENV.fetch('CONTENTFUL_SPACE_ID', nil)
-    @default_locale = nil
+    @default_locale = 'en-US'
+    @locale_fallbacks = {}
     @middleware = []
     @update_schema_file = :if_possible
     @schema_file = 'db/contentful-schema.json'
@@ -242,7 +249,7 @@ class WCC::Contentful::Configuration
     def initialize(configuration)
       ATTRIBUTES.each do |att|
         val = configuration.public_send(att)
-        val.freeze if val.is_a?(Hash) || val.is_a?(Array)
+        val = val.dup.freeze if val.is_a?(Hash) || val.is_a?(Array)
         instance_variable_set("@#{att}", val)
       end
     end

data/lib/wcc/contentful/downloads_schema.rb

@@ -25,7 +25,8 @@ class WCC::Contentful::DownloadsSchema
 
     File.write(@file, format_json({
       'contentTypes' => content_types,
-      'editorInterfaces' => editor_interfaces
+      'editorInterfaces' => editor_interfaces,
+      'locales' => locales
     }))
   end
 
@@ -45,8 +46,11 @@ class WCC::Contentful::DownloadsSchema
 
     existing_eis = contents['editorInterfaces'].sort_by { |i| i.dig('sys', 'contentType', 'sys', 'id') }
     return true unless editor_interfaces.count == existing_eis.count
+    return true unless deep_contains_all(editor_interfaces, existing_eis)
 
-    !deep_contains_all(editor_interfaces, existing_eis)
+    existing_locales = contents['locales'].sort_by { |i| i.dig('sys', 'contentType', 'sys', 'id') }
+    return true unless locales.count == existing_locales.count
+    return true unless deep_contains_all(locales, existing_locales)
   end
 
   def content_types
@@ -65,6 +69,14 @@ class WCC::Contentful::DownloadsSchema
         .sort_by { |i| i.dig('sys', 'contentType', 'sys', 'id') }
   end
 
+  def locales
+    @locales ||=
+      @client.locales(limit: 1000)
+        .items
+        .map { |l| strip_sys(l) }
+        .sort_by { |l| l.dig('sys', 'code') }
+  end
+
   private
 
   def strip_sys(obj)

data/lib/wcc/contentful/entry_locale_transformer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+##
+# This class provides helper methods to transform Entry and Asset hashes from
+# the "locale=*" format to a specific locale, and vice versa.
+module WCC::Contentful::EntryLocaleTransformer
+  extend self
+
+  # Attribute reader falling back to WCC::Contentful configuration
+  # needed for locale fallbacks
+  def configuration
+    @configuration || WCC::Contentful.configuration
+  end
+
+  ##
+  # Takes an entry which represents a specific 'sys.locale' and transforms it
+  # to the 'locale=*' format
+  def transform_to_star(entry)
+    # locale=* entries have a nil sys.locale
+    unless entry_locale = entry.dig('sys', 'locale')
+      # nothing to do
+      return entry
+    end
+
+    sys = entry['sys'].except('locale').merge({
+      'WCC::Contentful::EntryLocaleTransformer:locales_included' => [entry_locale]
+    })
+    fields =
+      entry['fields'].transform_values do |value|
+        h = {}
+        h[entry_locale] = value
+        h
+      end
+
+    {
+      'sys' => sys,
+      'fields' => fields
+    }
+  end
+
+  ##
+  # Takes an entry in the 'locale=*' format and transforms it to a specific locale
+  def transform_to_locale(entry, locale)
+    # If the backing store already returned a localized entry, nothing to do
+    if entry_locale = entry.dig('sys', 'locale')
+      unless entry_locale == locale
+        raise WCC::Contentful::LocaleMismatchError,
+          "expected #{locale} but was #{entry_locale}"
+      end
+
+      return entry
+    end
+    return entry unless entry['fields']
+
+    # Transform the store's "locale=*" entry into a localized one
+    locale ||= default_locale
+
+    sys = entry['sys'].deep_dup
+    sys['locale'] = locale
+    fields =
+      entry['fields'].transform_values do |value|
+        next if value.nil?
+
+        # replace the all-locales value with the localized value
+        l = locale
+        v = nil
+        while l
+          v = value[l]
+          break if v
+
+          l = configuration.locale_fallbacks[l]
+        end
+
+        v
+      end
+
+    {
+      'sys' => sys,
+      'fields' => fields
+    }
+  end
+
+  ##
+  # Takes an entry in a specific 'sys.locale' and merges it into an entry that is
+  # in the 'locale=*' format
+  def reduce_to_star(memo, entry)
+    if memo_locale = memo.dig('sys', 'locale')
+      raise WCC::Contentful::LocaleMismatchError, "expected locale: * but was #{memo_locale}"
+    end
+    unless entry_locale = entry.dig('sys', 'locale')
+      raise WCC::Contentful::LocaleMismatchError, 'expected a specific locale but got locale: *'
+    end
+
+    if memo.dig('sys', 'id') != entry.dig('sys', 'id')
+      raise ArgumentError,
+        "IDs of memo and entry must match! were (#{memo.dig('sys',
+          'id').inspect} and #{entry.dig('sys', 'id').inspect})"
+    end
+
+    entry['fields'].each do |key, value|
+      memo_field = memo['fields'][key] ||= {}
+      memo_field[entry_locale] = value
+    end
+
+    memo
+  end
+end

data/lib/wcc/contentful/exceptions.rb

@@ -36,4 +36,9 @@ module WCC::Contentful
 
   class InitializationError < StandardError
   end
+
+  # Raised by {WCC::Contentful::Middleware::Store::LocaleMiddleware} when the
+  # backing store loads an entry for the wrong locale.
+  class LocaleMismatchError < StandardError
+  end
 end

data/lib/wcc/contentful/link_visitor.rb

@@ -83,6 +83,7 @@ class WCC::Contentful::LinkVisitor
       end
       yield(raw_value, locale)
     else
+      # yield each locale in turn
       raw_value&.each_with_object({}) do |(l, val), h|
         h[l] = yield(val, l)
       end
@@ -105,8 +106,18 @@ class WCC::Contentful::LinkVisitor
   end
 
   def set_field(field, locale, index, val)
-    current_field = (entry['fields'][field] ||= {})
+    # default entry
+    if locale == entry.dig('sys', 'locale')
+      if index.nil?
+        entry['fields'][field] = val
+      else
+        (entry['fields'][field] ||= [])[index] = val
+      end
+      return
+    end
 
+    # locale=* entry
+    current_field = (entry['fields'][field] ||= {})
     if index.nil?
       current_field[locale] = val
     else

data/lib/wcc/contentful/middleware/store/caching_middleware.rb

@@ -6,7 +6,11 @@ module WCC::Contentful::Middleware::Store
     # include instrumentation, but not specifically store stack instrumentation
     include WCC::Contentful::Instrumentation
 
-    attr_accessor :expires_in
+    attr_accessor :expires_in, :configuration
+
+    def default_locale
+      @default_locale ||= configuration&.default_locale&.to_s || 'en-US'
+    end
 
     def initialize(cache = nil)
       @cache = cache || ActiveSupport::Cache::MemoryStore.new
@@ -22,22 +26,36 @@ module WCC::Contentful::Middleware::Store
           # Store a nil object if we can't find the object on the CDN.
           (store.find(key, **options) || nil_obj(key)) if key =~ /^\w+$/
         end
-      _instrument(event, key: key, options: options)
 
-      case found.try(:dig, 'sys', 'type')
-      when 'Nil', 'DeletedEntry', 'DeletedAsset'
-        nil
-      else
-        found
+      return unless found
+      return if %w[Nil DeletedEntry DeletedAsset].include?(found.dig('sys', 'type'))
+
+      # If what we found in the cache is for the wrong Locale, go hit the store directly.
+      # Now that the one locale is in the cache, when we index next time we'll index the
+      # all-locales version and we'll be fine.
+      locale = options[:locale]&.to_s || default_locale
+      found_locale = found.dig('sys', 'locale')&.to_s
+      if found_locale && (found_locale != locale)
+        event = 'miss'
+        return store.find(key, **options)
       end
+
+      found
+    ensure
+      _instrument(event, key: key, options: options)
     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)
+      options ||= {}
       if filter&.keys == ['sys.id'] && found = @cache.read(filter['sys.id'])
-        return found
+        # This is equivalent to a find, usually this is done by the resolver to
+        # try to include deeper relationships.  Since we already have this object,
+        # don't hit the API again.
+        return if %w[Nil DeletedEntry DeletedAsset].include?(found.dig('sys', 'type'))
+        return found if found.dig('sys', 'locale') == options[:locale]
       end
 
       store.find_by(content_type: content_type, filter: filter, options: options)
@@ -73,15 +91,21 @@ module WCC::Contentful::Middleware::Store
       id = json.dig('sys', 'id')
       type = json.dig('sys', 'type')
       prev = @cache.read(id)
-      return if prev.nil? && LAZILY_CACHEABLE_TYPES.include?(type)
+      if prev.nil? && LAZILY_CACHEABLE_TYPES.include?(type)
+        _instrument('miss.index', key: id, type: type, prev: nil, next: nil)
+        return
+      end
 
       if (prev_rev = prev&.dig('sys', 'revision')) && (next_rev = json.dig('sys', 'revision')) && (next_rev < prev_rev)
+        _instrument('miss.index', key: id, type: type, prev: prev_rev, next: next_rev)
         return prev
       end
 
       # we also set DeletedEntry objects in the cache - no need to go hit the API when we know
       # this is a nil object
-      @cache.write(id, json, expires_in: expires_in)
+      _instrument('write.index', key: id, type: type, prev: prev_rev, next: next_rev) do
+        @cache.write(id, json, expires_in: expires_in)
+      end
 
       case type
       when 'DeletedEntry', 'DeletedAsset'

data/lib/wcc/contentful/middleware/store/locale_middleware.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Middleware::Store
+  ##
+  # This middleware enforces that all entries returned by the store layer are properly localized.
+  # It does this by transforming entries from the store's "locale=*" format into the specified locale (or default).
+  #
+  # Stores keep entries in the "locale=*" format, which is a hash of all locales for each field.  This is convenient
+  # because the Sync API returns them in this format.  However, the Model layer requires localized entries.  So, to
+  # separate concerns, this middleware handles the transformation.
+  class LocaleMiddleware
+    include WCC::Contentful::Middleware::Store
+    include WCC::Contentful::EntryLocaleTransformer
+
+    attr_accessor :configuration
+
+    def default_locale
+      @default_locale ||= configuration&.default_locale&.to_s || 'en-US'
+    end
+
+    def transform(entry, options)
+      locale = options[:locale]&.to_s || default_locale
+      if locale == '*'
+        transform_to_star(entry)
+      else
+        transform_to_locale(entry, locale)
+      end
+    end
+  end
+end

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

@@ -33,18 +33,20 @@ module WCC::Contentful::Middleware::Store
 
   def find(id, **options)
     found = store.find(id, **options)
-    return transform(found) if found && (!has_select? || select?(found))
+    return transform(found, options) if found && (!has_select? || select?(found, options))
   end
 
   def find_by(options: nil, **args)
+    options ||= {}
     result = store.find_by(**args.merge(options: options))
-    return unless result && (!has_select? || select?(result))
+    return unless result && (!has_select? || select?(result, options))
 
-    result = resolve_includes(result, options[:include]) if options && options[:include]
-    transform(result)
+    result = resolve_includes(result, options[:include], options) if options && options[:include]
+    transform(result, options)
   end
 
   def find_all(options: nil, **args)
+    options ||= {}
     DelegatingQuery.new(
       store.find_all(**args.merge(options: options)),
       middleware: self,
@@ -52,20 +54,20 @@ module WCC::Contentful::Middleware::Store
     )
   end
 
-  def resolve_includes(entry, depth)
+  def resolve_includes(entry, depth, options)
     return entry unless entry && depth && depth > 0
 
     # We only care about entries (see #resolved_link?)
-    WCC::Contentful::LinkVisitor.new(entry, :Entry, depth: depth).map! do |val|
-      resolve_link(val)
+    WCC::Contentful::LinkVisitor.new(entry, :Entry, :Asset, depth: depth).map! do |val|
+      resolve_link(val, options)
     end
   end
 
-  def resolve_link(val)
+  def resolve_link(val, options)
     return val unless resolved_link?(val)
 
-    if !has_select? || select?(val)
-      transform(val)
+    if !has_select? || select?(val, options)
+      transform(val, options)
     else
       # Pretend it's an unresolved link -
       # matches the behavior of a store when the link cannot be retrieved
@@ -74,7 +76,7 @@ module WCC::Contentful::Middleware::Store
   end
 
   def resolved_link?(value)
-    value.is_a?(Hash) && value.dig('sys', 'type') == 'Entry'
+    value.is_a?(Hash) && %w[Entry Asset].include?(value.dig('sys', 'type'))
   end
 
   def has_select? # rubocop:disable Naming/PredicateName
@@ -83,7 +85,7 @@ module WCC::Contentful::Middleware::Store
 
   # The default version of `#transform` just returns the entry.
   # Override this with your own implementation.
-  def transform(entry)
+  def transform(entry, _options)
     entry
   end
 
@@ -110,11 +112,13 @@ module WCC::Contentful::Middleware::Store
 
     def to_enum
       result = wrapped_query.to_enum
-      result = result.select { |x| middleware.select?(x) } if middleware.has_select?
+      result = result.select { |x| middleware.select?(x, options) } if middleware.has_select?
 
-      result = result.map { |x| middleware.resolve_includes(x, options[:include]) } if options && options[:include]
+      if options && options[:include]
+        result = result.map { |x| middleware.resolve_includes(x, options[:include], options) }
+      end
 
-      result.map { |x| middleware.transform(x) }
+      result.map { |x| middleware.transform(x, options) }
     end
 
     def apply(filter, context = nil)
@@ -150,7 +154,7 @@ module WCC::Contentful::Middleware::Store
     def initialize(wrapped_query, middleware:, options: nil, **extra)
       @wrapped_query = wrapped_query
       @middleware = middleware
-      @options = options
+      @options = options || {}
       @extra = extra
     end
   end

data/lib/wcc/contentful/model_builder.rb

@@ -59,10 +59,16 @@ module WCC::Contentful
 
           define_method(:initialize) do |raw, context = nil|
             ct = content_type_from_raw(raw)
-            if ct != typedef.content_type
+            if ct.present? && ct != typedef.content_type
               raise ArgumentError, 'Wrong Content Type - ' \
                                    "'#{raw.dig('sys', 'id')}' is a #{ct}, expected #{typedef.content_type}"
             end
+            if raw.dig('sys', 'locale').blank? && %w[Entry Asset].include?(raw.dig('sys', 'type'))
+              raise ArgumentError, 'Model layer cannot represent "locale=*" entries. ' \
+                                   "Please use a specific locale in your query.  \n" \
+                                   "(Error occurred with entry id: #{raw.dig('sys', 'id')})"
+            end
+
             @raw = raw.freeze
 
             created_at = raw.dig('sys', 'createdAt')
@@ -72,7 +78,7 @@ module WCC::Contentful
             @sys = WCC::Contentful::Sys.new(
               raw.dig('sys', 'id'),
               raw.dig('sys', 'type'),
-              raw.dig('sys', 'locale') || context.try(:[], :locale) || 'en-US',
+              raw.dig('sys', 'locale'),
               raw.dig('sys', 'space', 'sys', 'id'),
               created_at,
               updated_at,
@@ -81,7 +87,8 @@ module WCC::Contentful
             )
 
             typedef.fields.each_value do |f|
-              raw_value = raw.dig('fields', f.name, @sys.locale)
+              raw_value = raw.dig('fields', f.name)
+
               if raw_value.present?
                 case f.type
                 # DateTime is intentionally not parsed!