wcc-contentful 1.3.0 → 1.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9026bfcc1e7745f7d8ecf3fb38928672f02d663d382fd1a3ca953ab33a78cb25
-  data.tar.gz: 36ec7c7f47fb6e49d565d7ca82c5021ac8f88b46eabfe41754ac5c123ac0004d
+  metadata.gz: 40c4c53ea7b5054745f8cd28841d59934a2e83ea65e4658e64124533412500bb
+  data.tar.gz: 53150802f51676dafc356812578159c23670335b8066c0536ad0d0b89fb094fd
 SHA512:
-  metadata.gz: 633116bd83752074876ccf76265eb64bc6a19a28b9a477bf2026925f0a84977cd651a234f5656b7a657a43e65b3320031e2385ca398bb2b846ab730693105799
-  data.tar.gz: 32f1f08bac98d42d89a136c0b49d2bb1ee1a72e057326edd50a17834b53b2da7fecbbe1db1aded355d2849bc1d222d4f16d3e721024a3c105f786349ab6548fc
+  metadata.gz: cd9ad6f0e34c388c12bc55fb7a62e5a55463f83fa0b09c0964e9f990d373ef142c890d54b8d77d6cd5e4e8e53a3c199919163268b2fddba7ec79e6f39e040a18
+  data.tar.gz: 1102e99319ded82fdef9293b06f68dae7d06b978696f6c12afe094f467d8f8cfff7242ada67e2adebed4b2903e279bd637ac468569dbf79a786e3ed07244337d

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)
@@ -394,10 +418,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 +464,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
@@ -565,7 +632,10 @@ to multiple spaces within the same ruby process!  You just have to create and in
 The {WCC::Contentful::ModelAPI} concern makes this straightforward.  Start by creating your Namespace
 and including the concern:
 ```ruby
-# app/models/my_second_space.rb
+# lib/my_second_space.rb
+
+# Note: This class must be in the "lib" folder in :zeitwerk mode, otherwise Rails 6+ will unload all your constants
+# that were created in the initializer.  Your models which subclass this namespace may reside in the app/models directory.
 class MySecondSpace
   include WCC::Contentful::ModelAPI
 end
@@ -587,6 +657,11 @@ MySecondSpace.configure do |config|
   config.space = ENV['SECOND_CONTENTFUL_SPACE_ID']
   config.environment = ENV['CONTENTFUL_ENVIRONMENT']
 end
+
+# Ensure that models are reloaded in Rails development mode
+Rails.application.config.to_prepare do
+  MySecondSpace.reload!
+end
 ```
 
 Finally, use it:
@@ -614,6 +689,22 @@ sync_engine = MySecondSpace.services.sync_engine
 Note that the above services are not accessible on {WCC::Contentful::Services.instance}
 or via the {WCC::Contentful::ServiceAccessors}.
 
+#### Important Note when using Zeitwerk with Rails 6+
+When using Rails >= 6 with `config.autoloader = :zeitwerk`, Rails will remove any models defined in `app/models` after
+initialization and then load them again when they are referenced.  If you `include WCC::Contentful::ModelAPI` in a class
+defined inside the `app` directory, this will have the effect of deleting all configuration that was set in the initializer
+as well as the constants generated from your schema.
+This will result in one of two errors:
+
+* `NameError (uninitialized constant MySecondSpace::MyContentType)`  
+    if you try to reference a subclass such as `MyContentType < MySecondSpace::MyContentType`
+* `ArgumentError (Not yet configured!)`
+    if you try to `MySecondSpace.find('xxxx')` to load an Entry or Asset
+
+The solution is to have your secondary namespace in a folder which is not in the `autoload_paths`.
+We suggest using `lib`, which will work so long as you have not added the `lib` folder to the `autoload_paths` as some
+uninformed StackOverflow answers suggest you do.
+
 ### Using a sync store with a second space
 
 If you use something other than the CDNAdapter with your second space, you will

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,35 @@ 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
+      if found.dig('sys', '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)

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_api.rb

@@ -96,7 +96,7 @@ module WCC::Contentful::ModelAPI
       loop do
         begin
           # The app may have defined a model and we haven't loaded it yet
-          const = parent.const_missing(const_name)
+          const = parent.const_get(const_name)
           return const if const && const < self
         rescue NameError => e
           raise e unless e.message =~ /uninitialized constant (.+::)*#{const_name}$/
@@ -156,7 +156,7 @@ module WCC::Contentful::ModelAPI
         const_name = klass.name
         begin
           # the const_name is fully qualified so search from root
-          const = Object.const_missing(const_name)
+          const = Object.const_get(const_name)
           register_for_content_type(content_type, klass: const) if const
         rescue NameError => e
           msg = "Error when reloading constant #{const_name} - #{e}"

data/lib/wcc/contentful/model_builder.rb

@@ -63,6 +63,12 @@ module WCC::Contentful
               raise ArgumentError, 'Wrong Content Type - ' \
                                    "'#{raw.dig('sys', 'id')}' is a #{ct}, expected #{typedef.content_type}"
             end
+            if raw.dig('sys', 'locale').blank?
+              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!