fortnox-api 1.0.0.rc12 → 1.0.0.rc14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a383d4f26222585f14be0a06145f63bb4584f8033e2eae2f91dc22cc513c085
-  data.tar.gz: 71fe26b84df2f8bb30ddcd990b39742606827b507164d42f8b05594b069f8ad6
+  metadata.gz: 1c59313b416138bb0a0544e45c6b2e4166937a184cf95112247a5d45f5a44418
+  data.tar.gz: 25d19b69aed753b8099edafcab818c0b6b64ec989c1b2deb57d819b4aae3f69d
 SHA512:
-  metadata.gz: c22875f971a82ee3b75168da1395ef21c75bb04ef4e521d550264435c840b5ea786abcde67d8234eded0a06d9ad4028e1926403daf62a3ed8355ae9adfd9634f
-  data.tar.gz: '08b942421e226597317d74e1189b3a4aca90fcc5158d8b4f6d27d934a791f2af57f80c9226f406015372286187fd286e43d271fcdb8b2e501380001f55ce43f7'
+  metadata.gz: 8f8d49aac36c3a995c580b3776b09ef7ac88047ae01a8dc3435c4287dd12bd68681e79668815853a38d5318e3edbea156381b4298dbf398181fba52907bfdde4
+  data.tar.gz: 8066b72c5242c29bef520f44cce65b30e0a12b7d19318972daa887c0da181253fe95bbb9aee86fb532fb5d036148cf0c9f14424fa3a888357d43f102b5b311ed

data/CHANGELOG.md

@@ -8,6 +8,123 @@ and this project adheres to
 
 ## [Unreleased]
 
+## [1.0.0.rc14] - 2026-08-11
+
+### Changed
+
+- The `base64` runtime dependency is now bounded to `~> 0.2`, matching what
+  `rest-easy` already requires. It was declared open-ended when it was added
+  in 1.0.0.rc7, so a future `base64` 1.0 with a breaking change would have
+  been resolved into consumers' bundles unannounced.
+
+### Added
+
+- **Breaking** `Fortnox::UnknownAttributeError`, raised when `new`, `stub` or
+  `update` is passed an attribute the resource or struct doesn't declare.
+  Previously the attribute was silently discarded: the request went out
+  without it and Fortnox accepted the result, so a typo cost a field with no
+  indication anything was wrong. Worst on nested rows, where
+  `stub(order_rows: [{ artcile_number: '1' }])` sent `"OrderRows":[{}]` and
+  created an order with empty rows. Subclasses `Fortnox::AttributeError` and
+  carries `.attribute_names` (all of them) and `.attribute_name` (the first).
+  Consumers passing a wider hash than the resource declares must slice it
+  first. Parsing an API response is unaffected and stays tolerant of fields
+  the gem doesn't declare — Fortnox adds them over time, and a response must
+  not fail to parse because of one.
+- Attribute hashes now accept string keys as well as symbols, on `new`,
+  `stub`, `update` and struct constructors. Previously a string key matched
+  nothing and was dropped, which is how a Rails controller passing `params`
+  through produced records missing every field.
+- Optional Rails integration, `require 'fortnox/rails'`. Defines `as_json` on
+  resources, collections and nested structs so `render json:` works when they
+  are nested inside another structure — ActiveSupport walks nested objects
+  with `as_json`, and without a definition falls through to `Object#as_json`,
+  which serialises instance variables and leaks `api_data`,
+  `model_attributes`, `changes` and `meta` into response bodies. The file is
+  not loaded with the rest of the gem and ActiveSupport is not a runtime
+  dependency; requiring it is opt-in for apps that already have Rails.
+
+### Fixed
+
+- `to_json` on a resource holding nested structs no longer renders them
+  through `to_s`. An invoice or order with rows serialised them as
+  `"#<Fortnox::Structs::InvoiceRow:0x…>"`. `Fortnox::Struct#to_json` and
+  `Fortnox::Collection#to_json` are defined for the same reason — both
+  previously fell back to the default `Object#to_json`, producing an
+  inspect string rather than JSON. All three render the model representation
+  (snake_case attribute names); `to_api` still produces the Fortnox wire
+  format. This affects all consumers, not only Rails apps.
+- Nested structs (`Fortnox::Structs::*`) now coerce boolean attributes from
+  the string spellings params arrive as (`'true'`, `'false'`, `'yes'`,
+  `'no'`, `'1'`, `'0'`, `'on'`, `'off'`), matching what resource attributes
+  have always accepted. Previously the struct-level type was strict and
+  rejected every string, so `Order.stub(order_rows: [{ housework: 'true' }])`
+  failed while the equivalent value on a resource attribute coerced cleanly
+  — callers passing Rails controller params had to cast booleans by hand
+  before building rows. Affects `DocumentRow#housework` and the `InvoiceRow`
+  and `OrderRow` subclasses. This asymmetry was introduced in 1.0.0.rc1 and
+  did not exist in 0.x.
+- Struct construction now raises Fortnox-namespaced errors. A bad value in a
+  nested struct — reached directly via `Fortnox::Structs::OrderRow.new` or
+  indirectly via `stub`/`update` with a nested hash — previously raised
+  `Dry::Struct::Error`, which is a `TypeError` outside the `Fortnox::Error`
+  hierarchy, so `rescue Fortnox::AttributeError` blocks didn't catch it. It
+  now raises `Fortnox::ConstraintError` carrying `.attribute_name` and
+  `.value`, with the same message format as the resource-level error. This
+  extends the error translation added in 1.0.0.rc13, which covered resources
+  but not structs.
+
+## [1.0.0.rc13] - 2026-08-04
+
+### Changed
+
+- **Breaking** String attributes now normalise `''` to `nil` at the type level. This
+  is the mechanism behind the reset fix below: Fortnox silently ignores
+  empty strings in update payloads — updating an attribute to `''` kept
+  the original value — and a field can only be cleared with an explicit
+  `null`. Normalising in the type also changes the read side: unset
+  string attributes read as `nil` in the model, never `''`. Fortnox
+  spells "unset" as `""` or `null` depending on endpoint and record
+  history, so the model value was previously unpredictable. Consumers
+  comparing against `''` must switch to `nil` checks (or call `.to_s`
+  if they prefer empty strings). On create, an attribute set to `''`
+  is now omitted from the POST body entirely (new records strip
+  `nil`s), leaving the field to Fortnox's default — previously `""`
+  was sent, which Fortnox ignores, with the same end result.
+  Enum-typed attributes whose value set
+  includes `''` (`payment_way`, `accounting_method`, `invoice_type`,
+  `tax_reduction_type`, `delivery_state`) are exempt: there `''` is a
+  real Fortnox value, not an unset spelling. For required string attributes
+  (`Customer#name`, `Article#description`, `Unit#code`/`#description`,
+  `TermsOfPayment#code`) this means updating to `''` now raises
+  `Fortnox::MissingAttributeError` before any request is made —
+  previously the empty string was sent and silently ignored by Fortnox
+  (clearing a required field is invalid: Fortnox rejects `null` for
+  them with a 400 and ignores `""`).
+
+### Fixed
+
+- Resetting a string attribute to `''` on update now clears the value in
+  Fortnox. Previously the empty string was silently ignored by Fortnox
+  and the old value was left intact (reported for `Customer#comments`).
+  Since `''` now coerces to `nil` (see above), both `update(attr: '')`
+  and `update(attr: nil)` reach Fortnox as `null`, which clears. This
+  includes the country attributes on documents (`country_code`,
+  `delivery_country`), whose mapper previously turned `nil` back into
+  `""` on the wire, so countries could never be cleared at all.
+- Numeric attributes no longer raise `Fortnox::ConstraintError` when
+  Fortnox returns `""` for an unset value — blank coerces to `nil`,
+  extending the 1.0.0.rc10 `Types::AccountNumber` fix to all integer
+  and float attributes (e.g. `Customer#invoice_discount`,
+  `Invoice#balance`). Like that bug, this was introduced in 1.0.0.rc1
+  and did not exist in 0.x, which coerced `""` to `0`/`0.0`.
+- `#update`, `#serialise` (and `#to_api`, which goes through it) and
+  `.new` now raise Fortnox-namespaced errors. A coercion failure like
+  `customer.update(email: 'not-an-email')` previously leaked
+  `RestEasy::ConstraintError`, which `rescue Fortnox::ConstraintError`
+  blocks don't catch — error translation only covered `save`, `parse`,
+  `find`, `stub` and the other class-level paths.
+
 ## [1.0.0.rc12] - 2026-06-26
 
 ### Fixed
@@ -281,7 +398,9 @@ for the full list of breaking changes.
 For changes prior to the 1.0 rewrite, see the
 [0.x changelog](https://github.com/accodeing/fortnox-api/blob/v0.9.2/CHANGELOG.md).
 
-[Unreleased]: https://github.com/accodeing/fortnox-api/compare/v1.0.0.rc12...HEAD
+[Unreleased]: https://github.com/accodeing/fortnox-api/compare/v1.0.0.rc14...HEAD
+[1.0.0.rc14]: https://github.com/accodeing/fortnox-api/compare/v1.0.0.rc13...v1.0.0.rc14
+[1.0.0.rc13]: https://github.com/accodeing/fortnox-api/compare/v1.0.0.rc12...v1.0.0.rc13
 [1.0.0.rc12]: https://github.com/accodeing/fortnox-api/compare/v1.0.0.rc11...v1.0.0.rc12
 [1.0.0.rc11]: https://github.com/accodeing/fortnox-api/compare/v1.0.0.rc10...v1.0.0.rc11
 [1.0.0.rc10]: https://github.com/accodeing/fortnox-api/compare/v1.0.0.rc9...v1.0.0.rc10

data/README.md

@@ -397,6 +397,58 @@ hitting some other schema-drift issue — please open an issue. There's a
 maintainer-only knob to surface those warnings; see the
 [Developer readme](DEVELOPER_README.md) for details.
 
+### Rails
+
+Two things are worth setting up before you render or receive Fortnox data in
+a Rails app.
+
+**Rendering.** Require the Rails integration once, in an initializer:
+
+```ruby
+# config/initializers/fortnox.rb
+require 'fortnox/rails'
+```
+
+Without it, `render json:` only works for a resource passed on its own.
+Rendering one *inside* another structure walks it with `as_json`, which the
+gem's types don't define outside this file, so ActiveSupport falls back to
+serialising instance variables and your response body gets the gem's
+internals:
+
+```ruby
+# Without fortnox/rails
+render json: { invoices: [Fortnox::Invoice.find(1)] }
+# => {"invoices":[{"api_data":{…},"model_attributes":{…},"changes":[…],"meta":{…}}]}
+
+# With it
+# => {"invoices":[{"document_number":1,"invoice_rows":[{"article_number":"101"}],…}]}
+```
+
+It covers resources, collections, and nested structs, and produces the same
+representation as `to_json` — model attribute names, not the Fortnox wire
+names. Rendering a collection yields its records, as an array would;
+pagination stays on the object (`.total`, `.pages`, `.current_page`) for you
+to render alongside if you want it.
+
+The file is not loaded with the rest of the gem and ActiveSupport is not a
+dependency of this gem — requiring it is opt-in, for apps that already have
+Rails.
+
+**Receiving params.** Controller params can be passed through as they arrive.
+String keys are accepted, and string values coerce — booleans from
+`'true'`/`'false'`/`'1'`/`'0'`/`'yes'`/`'no'`/`'on'`/`'off'`, numbers from
+their string forms:
+
+```ruby
+Fortnox::Order.stub('customer_number' => '1', 'order_rows' => [{ 'article_number' => '101' }])
+```
+
+An attribute the resource or struct doesn't declare raises
+`Fortnox::UnknownAttributeError` rather than being dropped, so a typo or a
+stray param surfaces at the call site instead of producing a record that is
+quietly missing a field. Filter params to the attributes you mean to accept,
+as you would for a model.
+
 ### Gotchas
 
 See [docs/gotchas.md](docs/gotchas.md) for known quirks and edge cases in the

data/fortnox.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 3.2.0'
 
-  spec.add_dependency 'base64'
+  spec.add_dependency 'base64', '~> 0.2'
   spec.add_dependency 'countries', '~> 7.1'
   spec.add_dependency 'dry-struct', '~> 1.5'
   spec.add_dependency 'rest-easy', '~> 1.4.0'

data/lib/fortnox/attribute_keys.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Fortnox
+  # Checks the attribute names a caller passes to `new`, `stub` and `update`.
+  #
+  # Both rest-easy and Dry::Struct build from the attributes they recognise and
+  # ignore everything else, so a typo or a string key used to vanish without a
+  # word: the request went out missing that field and Fortnox accepted it. The
+  # bigger the payload, the easier that is to miss.
+  #
+  # This only guards data a caller supplies. Parsing an API response stays
+  # tolerant of fields the gem doesn't declare — Fortnox adds them over time,
+  # and a response must not fail to parse because of one.
+  module AttributeKeys
+    module_function
+
+    def check(data, known:, subject:)
+      normalised = normalise(data)
+      unknown = normalised.keys - known
+      raise Fortnox::UnknownAttributeError.new(unknown, subject) unless unknown.empty?
+
+      normalised
+    end
+
+    # Rails hands params through with string keys. Accept them rather than
+    # reporting every attribute in the hash as unknown.
+    def normalise(data)
+      data.to_h { |key, value| [symbolise(key), value] }
+    end
+
+    # Left alone if it can't be a symbol, so it falls through to the unknown
+    # check and is reported as an attribute error rather than a NoMethodError.
+    def symbolise(key)
+      key.respond_to?(:to_sym) ? key.to_sym : key
+    end
+  end
+end

data/lib/fortnox/collection.rb

@@ -7,6 +7,7 @@ module Fortnox
   # the pagination metadata Fortnox returns alongside collection responses.
   class Collection
     include Enumerable
+    include Serialisation::CollectionJSON
     extend Forwardable
 
     def_delegators :@items, :each, :first, :last, :size, :length, :empty?, :[], :to_a

data/lib/fortnox/error_translation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Fortnox
+  # Translates rest-easy errors at the gem boundary so callers only see
+  # Fortnox-namespaced exceptions. Mixed into Fortnox::Resource both ways —
+  # `include` for the instance methods, `extend` for the class-level ones.
+  module ErrorTranslation
+    private
+
+    def with_translated_errors
+      yield
+    rescue RestEasy::ConstraintError => e
+      raise Fortnox::ConstraintError.new(e.attribute_name, e.value, e.message)
+    rescue RestEasy::MissingAttributeError => e
+      raise Fortnox::MissingAttributeError, e.attribute_name
+    rescue RestEasy::AttributeError => e
+      raise Fortnox::AttributeError, e.message
+    rescue RestEasy::RequestError => e
+      raise Fortnox::RequestError, e.response || e.message
+    end
+  end
+end

data/lib/fortnox/mappers/country_code.rb

@@ -7,8 +7,11 @@ module Fortnox
     module CountryCode
       ISO3166.configure { |config| config.locales = [:en, :sv] }
 
+      # Blank maps to nil in both directions, mirroring the string types:
+      # Fortnox spells "unset" country as "" on reads, and on updates only
+      # an explicit null clears the field — "" is silently ignored.
       def self.parse(country)
-        return '' if country.nil? || country == ''
+        return nil if country.nil? || country == ''
 
         # Fortnox only supports Swedish translation of Sweden
         return 'SE' if country =~ /^s(e$|we|ve)/i
@@ -23,7 +26,7 @@ module Fortnox
       end
 
       def self.serialise(country_code)
-        return '' if country_code.nil? || country_code == ''
+        return nil if country_code.nil? || country_code == ''
 
         return 'Sverige' if country_code == 'SE'
 

data/lib/fortnox/mappers/struct.rb

@@ -33,7 +33,11 @@ module Fortnox
           attributes = data.transform_keys do |api_key|
             api_to_model_map[api_key] || CONVENTION.parse(api_key)
           end
-          struct_class.new(attributes)
+          # Drop fields the struct doesn't declare. Fortnox adds them over
+          # time, and a response must not fail to parse because of one — the
+          # strictness on `new` is aimed at what a caller passes, not at what
+          # the API returns.
+          struct_class.new(attributes.slice(*struct_class.attribute_names))
         end
 
         def serialise(struct)

data/lib/fortnox/rails.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'fortnox'
+require 'active_support/json'
+
+# Optional Rails integration. Not loaded with the rest of the gem — require it
+# explicitly, e.g. from config/initializers/fortnox.rb:
+#
+#   require 'fortnox/rails'
+#
+# Rails serialises nested objects by calling `as_json` on them. Anything that
+# doesn't define it falls through to `Object#as_json`, which dumps instance
+# variables — so without this, `render json: { invoices: [invoice] }` puts the
+# gem's internals (`api_data`, `model_attributes`, `changes`, `meta`) in the
+# response body. `to_json` needs no help here; it is correct without Rails.
+module Fortnox
+  # Deliberately not named `Rails`: inside `module Fortnox` that constant would
+  # shadow the framework's own for every other file in the gem.
+  module RailsSerialisation
+    # `:only` / `:except` are applied by Fortnox::Serialisation rather than by
+    # ActiveSupport, so they accept string and symbol names alike. The inner
+    # `as_json` is then called without options — it only needs to stringify
+    # keys and recurse into nested structs.
+    module ResourceMethods
+      # Same representation `to_json` produces: model attribute names.
+      def as_json(options = nil)
+        Serialisation.filter(model.attributes, options).as_json
+      end
+    end
+
+    module StructMethods
+      def as_json(options = nil)
+        Serialisation.filter(to_h, options).as_json
+      end
+    end
+
+    module CollectionMethods
+      def as_json(options = nil)
+        to_a.map { |item| item.as_json(options) }
+      end
+    end
+  end
+end
+
+Fortnox::Resource.include(Fortnox::RailsSerialisation::ResourceMethods)
+Fortnox::Struct.include(Fortnox::RailsSerialisation::StructMethods)
+Fortnox::Collection.include(Fortnox::RailsSerialisation::CollectionMethods)

data/lib/fortnox/resource.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
 module Fortnox
+  # TODO: this class is still over the length limit even with error
+  # translation extracted — see todo.md.
+  # rubocop:disable Metrics/ClassLength
   class Resource < RestEasy::Resource
     include Fortnox::Types
+    include Serialisation::ResourceJSON
 
     settings do
       setting :instance_wrapper, reader: true
@@ -26,6 +30,9 @@ module Fortnox
 
     after_serialise { |data| default_after_serialise(data) }
 
+    include ErrorTranslation # instance-level methods
+    extend ErrorTranslation # class-level methods
+
     class << self
       attr_reader :registered_resources
 
@@ -42,8 +49,12 @@ module Fortnox
         end
       end
 
+      def new(model_data = {}, **kwargs)
+        with_translated_errors { super(checked_attributes(model_data.merge(kwargs))) }
+      end
+
       def stub(**model_data)
-        with_translated_errors { super }
+        with_translated_errors { super(**checked_attributes(model_data)) }
       end
 
       def save(instance)
@@ -94,18 +105,11 @@ module Fortnox
 
       private
 
-      # Translate rest-easy errors at the gem boundary so callers only see
-      # Fortnox-namespaced exceptions.
-      def with_translated_errors
-        yield
-      rescue RestEasy::ConstraintError => e
-        raise Fortnox::ConstraintError.new(e.attribute_name, e.value, e.message)
-      rescue RestEasy::MissingAttributeError => e
-        raise Fortnox::MissingAttributeError, e.attribute_name
-      rescue RestEasy::AttributeError => e
-        raise Fortnox::AttributeError, e.message
-      rescue RestEasy::RequestError => e
-        raise Fortnox::RequestError, e.response || e.message
+      # Attribute names a caller may pass. Read-only attributes are included:
+      # rest-easy drops them from the payload later, and rejecting them here
+      # would break round-tripping a parsed record back through `update`.
+      def checked_attributes(data)
+        AttributeKeys.check(data, known: all_attribute_definitions.keys, subject: self)
       end
 
       def extract_pagination(data)
@@ -120,6 +124,14 @@ module Fortnox
       end
     end
 
+    def update(changes = {}, **kwargs)
+      with_translated_errors { super(self.class.send(:checked_attributes, changes.merge(kwargs))) }
+    end
+
+    def serialise(...)
+      with_translated_errors { super }
+    end
+
     private
 
     # Shared serialisation tail used by the base after_serialise hook. Exposed
@@ -140,4 +152,5 @@ module Fortnox
       { config.instance_wrapper => data }
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/fortnox/resources/article.rb

@@ -12,7 +12,7 @@ module Fortnox
     end
 
     # @url Direct URL to the record.
-    attr :url <=> '@url', Coercible::String.optional, :read_only
+    attr :url <=> '@url', UnsizedString, :read_only
 
     # True If the article is active
     attr :active, Bool.optional, Boolean
@@ -34,7 +34,7 @@ module Fortnox
     attr :description, Sized::String[200], :required
 
     # DisposableQuantity Disposable quantity of the article.
-    attr :disposable_quantity, Coercible::Float.optional, :read_only
+    attr :disposable_quantity, UnsizedFloat, :read_only
 
     # EAN EAN bar code
     attr :ean <=> 'EAN', Sized::String[30]
@@ -80,14 +80,14 @@ module Fortnox
     attr :quantity_in_stock, Sized::Float[-100_000_000_000_000.0, 99_999_999_999_999.9]
 
     # ReservedQuantity Reserved quantity of the article
-    attr :reserved_quantity, Coercible::Float.optional, :read_only
+    attr :reserved_quantity, UnsizedFloat, :read_only
 
     # SalesAccount Account number for the sales account in Sweden.
     # The number must be of an existing account.
     attr :sales_account, Types::AccountNumber
 
     # SalesPrice Price of article for its default price list
-    attr :sales_price, Coercible::Float.optional, :read_only
+    attr :sales_price, UnsizedFloat, :read_only
 
     # StockGoods If the article is stock goods
     attr :stock_goods, Bool.optional, Boolean
@@ -96,27 +96,27 @@ module Fortnox
     attr :stock_place, Sized::String[100]
 
     # StockValue Value in stock of the article
-    attr :stock_value, Coercible::Float.optional, :read_only
+    attr :stock_value, UnsizedFloat, :read_only
 
     # StockWarning When to start warning for low quantity in stock
     attr :stock_warning, Sized::Float[0.0, 99_999_999_999_999.9]
 
     # SupplierName Name of the supplier
-    attr :supplier_name, Coercible::String.optional, :read_only
+    attr :supplier_name, UnsizedString, :read_only
 
     # SupplierNumber Supplier number for the article.
     # The number must be of an existing supplier.
-    attr :supplier_number, Coercible::String.optional
+    attr :supplier_number, UnsizedString
 
     # Type The type of the article
     attr :type, ArticleTypes
 
     # Unit Unit code for the article.
     # The code must be of an existing unit.
-    attr :unit, Coercible::String.optional
+    attr :unit, UnsizedString
 
     # VAT VAT percent, this is predefined by the VAT for the sales account
-    attr :vat <=> 'VAT', Coercible::Float.optional
+    attr :vat <=> 'VAT', UnsizedFloat
 
     # WebshopArticle If the article is a webshop article
     attr :webshop_article, Bool.optional, Boolean
@@ -131,7 +131,7 @@ module Fortnox
     attr :expired, Bool.optional, Boolean
 
     # CostCalculationMethod Cost calculation method used for the article.
-    attr :cost_calculation_method, Coercible::String.optional
+    attr :cost_calculation_method, UnsizedString
 
     # StockAccount Account number for stock.
     attr :stock_account, Types::AccountNumber
@@ -140,21 +140,21 @@ module Fortnox
     attr :stock_change_account, Types::AccountNumber
 
     # DirectCost Direct cost of the article.
-    attr :direct_cost, Coercible::Float.optional
+    attr :direct_cost, UnsizedFloat
 
     # FreightCost Freight cost of the article.
-    attr :freight_cost, Coercible::Float.optional
+    attr :freight_cost, UnsizedFloat
 
     # OtherCost Other cost of the article.
-    attr :other_cost, Coercible::Float.optional
+    attr :other_cost, UnsizedFloat
 
     # DefaultStockPoint Default stock point for the article.
-    attr :default_stock_point, Coercible::String.optional
+    attr :default_stock_point, UnsizedString
 
     # DefaultStockLocation Default stock location for the article.
-    attr :default_stock_location, Coercible::String.optional
+    attr :default_stock_location, UnsizedString
 
     # CommodityCode Commodity code of the article.
-    attr :commodity_code, Coercible::String.optional, :read_only
+    attr :commodity_code, UnsizedString, :read_only
   end
 end

data/lib/fortnox/resources/customer.rb

@@ -25,7 +25,7 @@ module Fortnox
     end
 
     # Direct URL to the record.
-    attr :url <=> '@url', Coercible::String.optional, :read_only
+    attr :url <=> '@url', UnsizedString, :read_only
 
     # First address of the customer
     attr :address1, Sized::String[1024]
@@ -37,7 +37,7 @@ module Fortnox
     attr :city, Sized::String[1024]
 
     # Country of the customer
-    attr :country, Coercible::String.optional, :read_only
+    attr :country, UnsizedString, :read_only
 
     # Comments
     attr :comments, Sized::String[1024]
@@ -46,7 +46,7 @@ module Fortnox
     attr :currency, Currencies
 
     # Cost center of the customer
-    attr :cost_center, Coercible::String.optional
+    attr :cost_center, UnsizedString
 
     # Country code of the customer
     attr :country_code, Sized::String[2]
@@ -70,7 +70,7 @@ module Fortnox
     attr :delivery_city, Sized::String[1024]
 
     # Delivery country of the customer
-    attr :delivery_country, Coercible::String.optional, :read_only
+    attr :delivery_country, UnsizedString, :read_only
 
     # Delivery country code of the customer
     attr :delivery_country_code, Sized::String[2]
@@ -145,7 +145,7 @@ module Fortnox
     attr :our_reference, Sized::String[50]
 
     # Phone number of the customer. Only present in collection responses.
-    attr :phone, Coercible::String.optional, :read_only
+    attr :phone, UnsizedString, :read_only
 
     # First phone number of the customer
     attr :phone1, Sized::String[1024]
@@ -154,10 +154,10 @@ module Fortnox
     attr :phone2, Sized::String[1024]
 
     # Price list of the customer
-    attr :price_list, Coercible::String.optional
+    attr :price_list, UnsizedString
 
     # Project of the customer
-    attr :project, Coercible::String.optional
+    attr :project, UnsizedString
 
     # Sales account of the customer
     attr :sales_account, Types::AccountNumber
@@ -166,16 +166,16 @@ module Fortnox
     attr :show_price_vat_included <=> 'ShowPriceVATIncluded', Bool.optional, Boolean
 
     # Terms of delivery code
-    attr :terms_of_delivery, Coercible::String.optional
+    attr :terms_of_delivery, UnsizedString
 
     # Terms of payment code
-    attr :terms_of_payment, Coercible::String.optional
+    attr :terms_of_payment, UnsizedString
 
     # Customer type
     attr :type, CustomerTypes
 
     # VAT number of the customer
-    attr :vat_number <=> 'VATNumber', Coercible::String.optional
+    attr :vat_number <=> 'VATNumber', UnsizedString
 
     # VAT type of the customer
     attr :vat_type <=> 'VATType', VATTypes
@@ -187,7 +187,7 @@ module Fortnox
     attr :visiting_city, Sized::String[128]
 
     # Visit country of the customer
-    attr :visiting_country, Coercible::String.optional, :read_only
+    attr :visiting_country, UnsizedString, :read_only
 
     # Visiting country code
     attr :visiting_country_code, Sized::String[2]
@@ -196,7 +196,7 @@ module Fortnox
     attr :visiting_zip_code, Sized::String[10]
 
     # Way of delivery code
-    attr :way_of_delivery, Coercible::String.optional
+    attr :way_of_delivery, UnsizedString
 
     # Your reference
     attr :your_reference, Sized::String[50]