digiwin_dsp 0.4.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ea76bd5a8bb2c25914e0f9bd6c40ff1fdf5ac6c6c0e83b6652b9a4c20f26a33
-  data.tar.gz: bca70e0fd5ba6f33831f2aaf4cf61aa29987a241d958dadd20539a34490bbf53
+  metadata.gz: 39cfa7cd414965f7f63ac143177e2dcb4ec36dee5403a7fc211f7a6d782d4ad1
+  data.tar.gz: 86333bb27dd34ad93c350cdf2b195237faac24ca3c5192e843e4d43958c0c578
 SHA512:
-  metadata.gz: dc0e854bc169fda091248b0048c9cf79ab0cad639b0cd431dfce867d3f9eaeaab737bad0f8103975bf9311efe99cd737b9bb05d65019cabfcb27ac8d77d1da7f
-  data.tar.gz: 619d56aa98ec48df0055bad21448618a244b8e29623429a07adaa8ca236229d7501ade6f978c69d7df3a495de1d5be6b5d6951e25f3ba050a18a9f6c4826176e
+  metadata.gz: 16f9fc374c1d7bb01d75f7963d616fb4fa26c649450700db75a54b7962756560371cb67f532d4afc06eb79f26d61561bbcfe94a376cd2f78f493814a364705d6
+  data.tar.gz: a6d881275de661e80a11ed41e0344bb1ec7848e681648c14c8449ddf38a1f153516c303ca36fd340c282fcf40748c1dbb44eade762aaf6adf371c13d7943e827

data/CHANGELOG.md

@@ -6,6 +6,36 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-22
+
+### BREAKING
+
+- **Date/time fields are format-checked before sending.** Every serializer now rejects malformed or impossible values (e.g. `20260230`, `25:00:00`) with `ValidationError`, per `docs/dsp-specs/*.yaml`: `create_datetime` `yyyy-MM-dd HH:mm:ss`; `order_date`, `invoice_date`, `order_expect_shipping_date` `YYYYMMDD`; `invoice_time` `HH:MM:SS`. Blank optional fields are skipped. **`invoice_time` without colons (`"123000"`) is now rejected** — DSP UAT accepted it, but the spec requires `HH:MM:SS` and DSP accepts invoice data unconditionally, so acceptance proved nothing about the ERP side. Values must be strings; `Time`/`Date` objects are rejected. The offending value is not echoed in the error message. Note: DSPOOFFICIAL001's `create_datetime` example uses slashes (`2024/01/10 04:48:45`), contradicting its own `yyyy-MM-dd HH:mm:ss` description; the slash form is rejected.
+
+### Changed
+
+- **HTTP 500, 502 and 504 are no longer retried.** A gateway error can arrive after DSP has already processed the POST, so resending risked a duplicate, or a spurious `DuplicateRequestError` on orders. They now raise `ServerError` right away. Only 429 and 503 are retried, plus pre-send connection failures.
+
+### Fixed
+
+- **`Client.new(base_url:)` is now checked against https + `allowed_hosts`.** The per-client override previously skipped the SSRF guard, so the API key could be sent to any host, even over plain http. `Configuration#validate_url!` is now public.
+- **`Webhooks.parse(nil, ...)` raises `Webhooks::ParseError`** instead of `TypeError`, which escaped `rescue DigiwinDsp::Error`.
+- **Serializers reject empty or non-Hash input** with `ValidationError`: `[]` used to be sent as an empty `request_detail`, and `nil` records raised `NoMethodError`.
+- **`allowed_hosts` matches hostnames case-insensitively**, so `https://DigiwinDSP.digiwin.com` is no longer rejected.
+
+## [0.5.0] - 2026-10-01
+
+### BREAKING
+
+- **Ruby 3.2 support dropped; supported range is now 3.3 – 4.0.** `required_ruby_version` is `>= 3.3.0` and CI runs 3.3 / 3.4 / 4.0. The dev-only `parallel < 2.0` pin (kept for the 3.2 CI row) is removed.
+
+### Fixed
+
+- **POSTs are no longer resent after a read timeout.** faraday-retry's defaults retried `Faraday::TimeoutError` for every method, so a slow DSP that had already created the order would see a resend and the caller would get a spurious `DuplicateRequestError` (or a real duplicate on invoice/return, which have no documented dedupe). Only failures that happen before the request is sent (connection refused, host/network unreachable, DNS failure, connect timeout) are retried now — which also makes the README's "connection failures" claim true; previously `Faraday::ConnectionFailed` was never retried.
+- **Non-object 2xx bodies raise `ServerError`** instead of being returned and blowing up as `NoMethodError` in `Resources::Base#create` / `WebhookSubscription#create` (outside the `DigiwinDsp::Error` tree, so `rescue`/`retry_on` missed it). A `{"std_data":"..."}` body no longer raises `TypeError` either.
+- **Malformed inbound webhooks raise `Webhooks::ParseError`** instead of `TypeError` when an envelope level isn't an object, and `InventoryUpdate` / `LogisticsUpdate` now reject a non-object `request` payload.
+- **`Configuration#environment=` accepts strings** (e.g. `c.environment = Rails.env`), matching the `DIGIWIN_DSP_ENV` path.
+
 ## [0.4.2] - 2026-06-18
 
 ### Added
@@ -264,7 +294,9 @@ Initial release. Covers the four Self-hosted Website Module (自有官網模組)
 - The gem is **synchronous on purpose**. Callers wrap requests in their own background job runner (e.g. ActiveJob) when needed.
 - Idempotency: clients can send `X-Idempotency-Key` via the `idempotency_key:` kwarg. DSP also dedupes server-side by `form_no + platform_id`.
 
-[Unreleased]: https://github.com/7a6163/digiwin_dsp/compare/v0.4.2...HEAD
+[Unreleased]: https://github.com/7a6163/digiwin_dsp/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/7a6163/digiwin_dsp/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/7a6163/digiwin_dsp/compare/v0.4.2...v0.5.0
 [0.4.2]: https://github.com/7a6163/digiwin_dsp/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/7a6163/digiwin_dsp/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/7a6163/digiwin_dsp/compare/v0.3.1...v0.4.0

data/README.md

@@ -1,10 +1,13 @@
 # digiwin_dsp
 
+[![Gem Version](https://badge.fury.io/rb/digiwin_dsp.svg)](https://badge.fury.io/rb/digiwin_dsp)
 [![CI](https://github.com/7a6163/digiwin_dsp/actions/workflows/ci.yml/badge.svg)](https://github.com/7a6163/digiwin_dsp/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/7a6163/digiwin_dsp/branch/main/graph/badge.svg)](https://codecov.io/gh/7a6163/digiwin_dsp)
-[![Ruby](https://img.shields.io/badge/ruby-%E2%89%A53.2-CC342D)](https://www.ruby-lang.org/)
+[![Ruby](https://img.shields.io/badge/ruby-3.3%E2%80%934.0-CC342D)](https://www.ruby-lang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE.txt)
 
+Homepage: <https://rubygems.org/gems/digiwin_dsp>
+
 Ruby client for the Digiwin DSP Self-hosted Website Module (自有官網模組) API. Lets your storefront push orders, cancellations, invoice updates, and returns into the Digiwin ERP through the DSP gateway.
 
 | Operation | Resource | Endpoint |
@@ -29,7 +32,7 @@ gem "digiwin_dsp"
 bundle install
 ```
 
-Ruby ≥ 3.2 required.
+Ruby 3.3 – 4.0 supported (≥ 3.3 required).
 
 ## Configuration
 
@@ -143,6 +146,8 @@ Each has its own required-field set (8 / 11 / 19 fields respectively). Inspect `
 DigiwinDsp::Serializers::CancellationSerializer::REQUIRED_FIELDS
 ```
 
+Date/time fields are format-checked locally on every endpoint (blank optional ones are skipped) and raise `ValidationError` if malformed: `create_datetime` → `"2026-05-20 12:00:00"`, `order_date` / `invoice_date` / `order_expect_shipping_date` → `"20260520"`, `invoice_time` → `"12:30:00"`. Pass strings, e.g. `t.strftime("%H:%M:%S")`; `Time`/`Date` objects are rejected.
+
 > ⚠️ **Invoice sync requires ERP-side customization.** Per DSPOOFFICIAL004's spec note (個案), DSP accepts your invoice data unconditionally, but it only becomes *visible inside the ERP* after Digiwin performs per-customer integration work. If invoices appear to sync successfully but the ERP team can't see them, this is why — confirm the customization with your Digiwin contact before debugging your own code.
 
 ### `order_status` enum
@@ -227,7 +232,8 @@ Every `Client#post` already retries transparently inside Faraday:
 | Setting | Value |
 |---|---|
 | Attempts | up to 4 (1 original + max 3 retries) |
-| Triggers | HTTP 429, 500, 502, 503, 504, connection failures |
+| Triggers | HTTP 429, 503; connection failures that happen *before* the request reaches DSP (refused, host/network unreachable, DNS failure, connect timeout) |
+| Never retried | HTTP 500, 502, 504 (raise `ServerError`), read timeouts and mid-request connection resets (raise `NetworkError`) — DSP may already have processed the POST, so resending could duplicate it. Check DSP state before retrying |
 | Backoff | exponential — ~0.5s, ~1s, ~2s between attempts, ±50% jitter |
 
 So one `Resources::Order.create` call can take up to ~`4 × timeout + 3.5s` in the worst case (default `timeout` 10s → ~44s). **Size your job timeouts and queue latency budgets accordingly** — if you also add `retry_on` in ActiveJob/Sidekiq (recommended for `RateLimitError`, which DSP signals via the envelope and the gem does *not* retry internally), the two layers multiply.
@@ -257,11 +263,11 @@ All exceptions inherit from `DigiwinDsp::Error` and carry structured attributes
 | Exception | Raised when |
 |---|---|
 | `DigiwinDsp::ConfigurationError` | `api_key` missing at request time |
-| `DigiwinDsp::ValidationError` | Required field missing locally, or DSP returns `WrongStatus:` / `Processing:取消訂單處理中` / HTTP 400 |
+| `DigiwinDsp::ValidationError` | Required field missing or date/time field malformed locally, or DSP returns `WrongStatus:` / `Processing:取消訂單處理中` / HTTP 400 |
 | `DigiwinDsp::AuthenticationError` | HTTP 401 / 403 |
 | `DigiwinDsp::DuplicateRequestError` | DSP returns `Duplicated:` or HTTP 409 |
 | `DigiwinDsp::RateLimitError` | DSP returns `Processing:資料處理中` (retryable) or persistent HTTP 429 |
-| `DigiwinDsp::ServerError` | DSP returns `系統異常:` or HTTP 5xx that exhausts retries |
+| `DigiwinDsp::ServerError` | DSP returns `系統異常:` or HTTP 5xx (503 only after retries are exhausted) |
 | `DigiwinDsp::NetworkError` | TCP connect failure or timeout |
 | `DigiwinDsp::Error` | Catch-all (unmapped failure message or unexpected status) |
 
@@ -324,7 +330,7 @@ DigiwinDsp::Resources::Order.create(
 
 ```bash
 bin/setup              # bundle install
-bundle exec rspec      # run the full test suite (134 examples, 100% coverage)
+bundle exec rspec      # run the full test suite (100% line coverage)
 bundle exec rubocop    # lint
 bin/console            # IRB with the gem loaded
 ```

data/lib/digiwin_dsp/client.rb

@@ -5,7 +5,10 @@ require "faraday/retry"
 
 module DigiwinDsp
   class Client
-    RETRY_STATUSES = [429, 500, 502, 503, 504].freeze
+    # Only statuses that mean "not processed". 500/502/504 are left out: a
+    # gateway error can arrive after DSP has already handled the POST, so a
+    # resend could duplicate it (same reasoning as read timeouts below).
+    RETRY_STATUSES = [429, 503].freeze
     # Exponential backoff: ~0.5s, ~1s, ~2s between attempts, ±50% jitter so
     # multiple Rails workers retrying the same upstream blip don't synchronize
     # into a thundering herd against DSP.
@@ -13,6 +16,29 @@ module DigiwinDsp
     RETRY_INTERVAL = 0.5
     RETRY_BACKOFF_FACTOR = 2
     RETRY_INTERVAL_RANDOMNESS = 0.5
+    # Transport failures that happen before the request reaches DSP, so a
+    # resend can't duplicate a POST. Read timeouts, ECONNRESET, EPIPE etc.
+    # are deliberately absent: DSP may already have processed the request.
+    PRE_SEND_ERRORS = [
+      Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, SocketError, Net::OpenTimeout
+    ].freeze
+    RETRY_IF = lambda do |_env, error|
+      !error.is_a?(Faraday::ConnectionFailed) ||
+        PRE_SEND_ERRORS.any? { |klass| error.wrapped_exception.is_a?(klass) }
+    end
+    RETRY_OPTIONS = {
+      max: RETRY_MAX,
+      interval: RETRY_INTERVAL,
+      backoff_factor: RETRY_BACKOFF_FACTOR,
+      interval_randomness: RETRY_INTERVAL_RANDOMNESS,
+      retry_statuses: RETRY_STATUSES,
+      # Faraday::TimeoutError is left out: a read timeout on a POST must not
+      # be resent (see PRE_SEND_ERRORS).
+      exceptions: [Faraday::ConnectionFailed, Faraday::RetriableResponse],
+      # Empty methods routes every retry decision through RETRY_IF.
+      methods: [],
+      retry_if: RETRY_IF
+    }.freeze
     USER_AGENT = "digiwin_dsp/#{VERSION} (Faraday/#{Faraday::VERSION})".freeze
 
     STATUS_ERROR_MAP = {
@@ -67,13 +93,7 @@ module DigiwinDsp
     def connection
       @connection ||= Faraday.new(url: connection_base_url, headers: default_headers) do |f|
         f.request :json
-        f.request :retry,
-                  max: RETRY_MAX,
-                  interval: RETRY_INTERVAL,
-                  backoff_factor: RETRY_BACKOFF_FACTOR,
-                  interval_randomness: RETRY_INTERVAL_RANDOMNESS,
-                  retry_statuses: RETRY_STATUSES,
-                  methods: %i[get post put patch delete]
+        f.request :retry, RETRY_OPTIONS
         # max_nesting caps deserialization depth so a hostile / malformed DSP
         # response can't allocate unbounded memory (DoS guard on the parser).
         f.response :json, content_type: /\bjson\z/, parser_options: { max_nesting: 50 }
@@ -85,7 +105,7 @@ module DigiwinDsp
     end
 
     def connection_base_url
-      base = @base_url_override || @configuration.base_url
+      base = @base_url_override&.tap { |url| @configuration.validate_url!(url) } || @configuration.base_url
       base.end_with?("/") ? base : "#{base}/"
     end
 
@@ -114,8 +134,12 @@ module DigiwinDsp
       klass.new(message, **error_attrs(status, body))
     end
 
+    # Every DSP endpoint answers with a JSON object; anything else on a 2xx
+    # (IIS HTML error page, empty body) would otherwise surface downstream
+    # as NoMethodError, outside the DigiwinDsp::Error tree. The body itself
+    # stays out of the message (PII).
     def inspect_envelope(body)
-      return body unless body.is_a?(Hash)
+      raise ServerError.new("DSP returned a non-JSON-object 2xx body (#{body.class})", http_status: 200) unless body.is_a?(Hash)
 
       failure = detect_envelope_failure(body)
       return body unless failure
@@ -128,7 +152,7 @@ module DigiwinDsp
     # - DSPOOFFICIAL100: { srvver, std_data: { execution: { code, description }, response } }
     # - DSPOOFFICIAL001-005: { Status, Message, response_detail }
     def detect_envelope_failure(body)
-      if (exec = body.dig("std_data", "execution"))
+      if (exec = execution_block(body))
         return nil if exec["code"].to_s == "0"
 
         { message: exec["description"].to_s, code: exec["code"] }
@@ -142,6 +166,13 @@ module DigiwinDsp
       end
     end
 
+    # Hash-checked dig: a 2xx like {"std_data":"x"} must not raise TypeError.
+    def execution_block(body)
+      std_data = body["std_data"]
+      exec = std_data["execution"] if std_data.is_a?(Hash)
+      exec if exec.is_a?(Hash)
+    end
+
     # Neither known envelope. If DSP ships a third shape, failures would
     # otherwise pass through as "success" silently — leave a trace.
     def warn_unknown_envelope(body)

data/lib/digiwin_dsp/configuration.rb

@@ -21,9 +21,15 @@ module DigiwinDsp
       production: "https://digiwindsp.digiwin.com/DSP/api/webhook"
     }.freeze
 
-    attr_accessor :api_key, :platform_id, :environment, :logger,
+    attr_accessor :api_key, :platform_id, :logger,
                   :timeout, :open_timeout, :allowed_hosts
     attr_writer :base_url, :webhook_base_url
+    attr_reader :environment
+
+    # Accept strings too (e.g. `c.environment = Rails.env`), like the ENV path.
+    def environment=(value)
+      @environment = value&.to_sym
+    end
 
     def initialize
       @api_key           = ENV["DIGIWIN_DSP_API_KEY"]
@@ -56,8 +62,26 @@ module DigiwinDsp
             "api_key is required (set via DigiwinDsp.configure or DIGIWIN_DSP_API_KEY)"
     end
 
+    # Public so Client can apply the same https + allowed_hosts guard to a per-client base_url override.
+    def validate_url!(url)
+      uri = URI.parse(url)
+      raise ConfigurationError, "base_url must use https (got #{uri.scheme.inspect})" unless uri.scheme == "https"
+      return if allowed_host?(uri.host)
+
+      raise ConfigurationError,
+            "base_url host #{uri.host.inspect} is not in allowed_hosts #{allowed_hosts.inspect}; " \
+            "add it via DigiwinDsp.configure { |c| c.allowed_hosts += [host] }"
+    rescue URI::InvalidURIError => e
+      raise ConfigurationError, "base_url is not a valid URI: #{e.message}"
+    end
+
     private
 
+    # DNS hostnames are case-insensitive.
+    def allowed_host?(host)
+      !host.nil? && allowed_hosts.any? { |h| h.casecmp?(host) }
+    end
+
     def resolve_default_base_url
       BASE_URLS.fetch(environment) do
         raise ConfigurationError,
@@ -71,17 +95,5 @@ module DigiwinDsp
               "unknown environment #{environment.inspect}; expected one of #{WEBHOOK_BASE_URLS.keys.inspect}"
       end
     end
-
-    def validate_url!(url)
-      uri = URI.parse(url)
-      raise ConfigurationError, "base_url must use https (got #{uri.scheme.inspect})" unless uri.scheme == "https"
-      return if allowed_hosts.include?(uri.host)
-
-      raise ConfigurationError,
-            "base_url host #{uri.host.inspect} is not in allowed_hosts #{allowed_hosts.inspect}; " \
-            "add it via DigiwinDsp.configure { |c| c.allowed_hosts += [host] }"
-    rescue URI::InvalidURIError => e
-      raise ConfigurationError, "base_url is not a valid URI: #{e.message}"
-    end
   end
 end

data/lib/digiwin_dsp/serializers/base.rb

@@ -1,10 +1,26 @@
 # frozen_string_literal: true
 
+require "date"
+
 module DigiwinDsp
   module Serializers
     # Mix into a serializer module via `extend Base`. The hosting module must
     # define a REQUIRED_FIELDS constant (array of string field names).
     module Base
+      # strftime formats from docs/dsp-specs/*.yaml. Checked on every endpoint
+      # whenever the field is present; blank optional fields are skipped.
+      FIELD_FORMATS = {
+        "create_datetime" => "%Y-%m-%d %H:%M:%S",
+        "order_date" => "%Y%m%d",
+        "invoice_date" => "%Y%m%d",
+        "order_expect_shipping_date" => "%Y%m%d",
+        "invoice_time" => "%H:%M:%S"
+      }.freeze
+
+      # Spec-style labels for error messages: "%Y-%m-%d" -> "YYYY-MM-DD".
+      # %m (month) and %M (minute) both read "MM", as in the DSP docs.
+      FORMAT_LABELS = { "%Y" => "YYYY", "%m" => "MM", "%d" => "DD", "%H" => "HH", "%M" => "MM", "%S" => "SS" }.freeze
+
       def serialize(records, digi_header: nil)
         normalized = normalize(records)
         validate!(normalized)
@@ -15,24 +31,47 @@ module DigiwinDsp
 
       def normalize(records)
         list = records.is_a?(Array) ? records : [records]
+        raise ValidationError, "records must not be empty" if list.empty?
+        # respond_to? rather than is_a?(Hash) so ActionController::Parameters keeps working.
+        raise ValidationError, "each record must be a Hash" unless list.all? { |r| r.respond_to?(:transform_keys) }
+
         list.map { |r| r.transform_keys(&:to_s) }
       end
 
       def validate!(records)
-        problems = []
-        total = records.size
-        total.times { |i| problems.concat(missing_fields(records[i], i, total)) }
-        return if problems.empty?
+        prefixes = records.size > 1 ? records.each_index.map { |i| "[#{i}]." } : [""]
+        pairs = records.zip(prefixes)
+        missing = pairs.flat_map { |r, pre| missing_fields(r, pre) }
+        invalid = pairs.flat_map { |r, pre| invalid_formats(r, pre) }
+        return if missing.empty? && invalid.empty?
 
-        raise ValidationError, "missing or empty required fields: #{problems.join(", ")}"
+        raise ValidationError, validation_message(missing, invalid)
       end
 
-      def missing_fields(record, index, total)
-        missing = self::REQUIRED_FIELDS.reject { |f| present?(record[f]) }
-        return [] if missing.empty?
+      def missing_fields(record, prefix)
+        self::REQUIRED_FIELDS.reject { |f| present?(record[f]) }.map { |f| "#{prefix}#{f}" }
+      end
+
+      # The offending value stays out of the message, matching the PII rule on errors.
+      def invalid_formats(record, prefix)
+        FIELD_FORMATS.filter_map do |field, format|
+          value = record[field]
+          "#{prefix}#{field} (expected #{format.gsub(/%[YmdHMS]/, FORMAT_LABELS)})" if present?(value) && !valid_format?(value, format)
+        end
+      end
+
+      # The strftime round-trip rejects what strptime tolerates: "2026-5-20", "20260520 ", "24:00:00".
+      def valid_format?(value, format)
+        value.is_a?(String) && DateTime.strptime(value, format).strftime(format) == value
+      rescue Date::Error
+        false
+      end
 
-        prefix = total > 1 ? "[#{index}]." : ""
-        missing.map { |f| "#{prefix}#{f}" }
+      def validation_message(missing, invalid)
+        parts = []
+        parts << "missing or empty required fields: #{missing.join(", ")}" if missing.any?
+        parts << "invalid format: #{invalid.join(", ")}" if invalid.any?
+        parts.join("; ")
       end
 
       def present?(value)

data/lib/digiwin_dsp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DigiwinDsp
-  VERSION = "0.4.2"
+  VERSION = "0.6.0"
 end

data/lib/digiwin_dsp/webhooks/event.rb

@@ -21,13 +21,21 @@ module DigiwinDsp
         JSON.parse(raw_body, max_nesting: 50)
       rescue JSON::ParserError => e
         raise ParseError, "invalid JSON: #{e.message}"
+      rescue TypeError
+        # A nil / non-String body (e.g. missing raw_post) must stay inside the DigiwinDsp::Error tree.
+        raise ParseError, "raw body must be a String (got #{raw_body.class})"
       end
 
       def self.extract_request(hash)
         raise ParseError, "envelope must be a JSON object" unless hash.is_a?(Hash)
 
-        hash.dig("digi_body", "std_data", "parameter", "request") ||
-          raise(ParseError, "envelope missing digi_body.std_data.parameter.request")
+        # Walk by hand: Hash#dig raises TypeError when an intermediate level
+        # is a String/Array, which would escape the DigiwinDsp::Error tree
+        # (webhooks are unsigned, so anyone can send such a body).
+        request = %w[digi_body std_data parameter request].reduce(hash) do |node, key|
+          node.is_a?(Hash) ? node[key] : nil
+        end
+        request || raise(ParseError, "envelope missing digi_body.std_data.parameter.request")
       end
 
       private_class_method :parse_json, :extract_request

data/lib/digiwin_dsp/webhooks/inventory_update.rb

@@ -6,6 +6,13 @@ module DigiwinDsp
     # See docs/dsp-specs/DSPOOFFICIAL100.yaml under
     # "庫存數量更新 product/inventory_update".
     class InventoryUpdate < Event
+      def self.parse(raw_body)
+        event = super
+        raise ParseError, "product/inventory_update payload must be a JSON object" unless event.request.is_a?(Hash)
+
+        event
+      end
+
       def prod         = request["prod"]
       def platform_id  = request["platform_id"]
       def sale_page_id = request["sale_page_id"]

data/lib/digiwin_dsp/webhooks/logistics_update.rb

@@ -6,6 +6,13 @@ module DigiwinDsp
     # delivered, etc.). See docs/dsp-specs/DSPOOFFICIAL100.yaml under
     # "倉儲貨態更新 wms/logistics/package/update".
     class LogisticsUpdate < Event
+      def self.parse(raw_body)
+        event = super
+        raise ParseError, "wms/logistics/package/update payload must be a JSON object" unless event.request.is_a?(Hash)
+
+        event
+      end
+
       def form_no          = request["form_no"]
       def func_name        = request["func_name"]
       def status_date      = request["status_date"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: digiwin_dsp
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Zac
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-18 00:00:00.000000000 Z
+date: 2026-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -101,7 +101,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="