jamm 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb73f3a736756e42ca49cedb1fb255e011fb39e0c34dabc2f85bfd537836afe1
-  data.tar.gz: d5ce67a32f315473bca8800024d19b939b9dafefb358a077e7f30fa551dd01ed
+  metadata.gz: 17f04171e0380f881d022d968eafaecfab7de2ca6e0a91ed56b217a4434afcab
+  data.tar.gz: 2f98a4766f79146afc5a839a26b2f69674ac87330065f663d9c90441a52b5f74
 SHA512:
-  metadata.gz: ff218dca883cf3515ce3d37a89147c6ce1a615fc53568f0916edb48211f6de1a5b4af7c5613066a74a3df017cd81ec76d734c9ecec259b3a78457af4eb3d4900
-  data.tar.gz: 69cd60e93b565297f43fd08f7b6a768a6ae5955dddd47d4553b18756e5a3123cdb6548e596e1c9317928f613064c96c66630de9783fab57229d146e78ecfcbe2
+  metadata.gz: 1182b1fc82f6d8c009e9f98542baf35e2b4542ff81f8b49ba4de35319662a8a2bcec5e47f35b2f45041a491f4d9c7697997259263426960d11493cefa0eef547
+  data.tar.gz: a17d3a2f3a352b39a8c2021593dc24e4d960afd460bc2ecdea038186b078e9df92d8b6e6b0e9965995cf50408c1327eef01dbd3ffd39909aa222636e8155b337

data/CHANGELOG.md

@@ -5,21 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.3.0] - 2026-06-24
+## [2.4.0] - 2026-07-01
 
 ### Added
 
-- Resolve numeric enum wire values (`status`, `api_source`, …) onto their string enum constants on every webhook model, matching REST API responses (the backend serializes webhooks with `json.Marshal`, so all enums arrive numeric)
-- Surface the refund `rfd-` id on the flat `refund_id` attribute in addition to the nested `refund.id`
-- Parse `EVENT_TYPE_USER_ACCOUNT_DELETED` webhooks (previously raised `Unknown event type`)
-
-### Fixed
-
-- Webhook parsing no longer fails on new fields added by the backend (forward-compatible)
-- Refund webhooks now expose the nested transaction fields and the refund's `rfd-` id (`refund.id`)
-- `status` on refund/charge webhooks is no longer left as a raw integer
-- Nested webhook fields (e.g. `refund.error`) are now typed model instances instead of raw Hashes, so `error.code` / `error.message` work instead of raising `NoMethodError`
-- `Webhook.parse` now accepts payloads with either string or symbol keys
+- Send the `X-SDK-Version` request header (`ruby:<version>`) so the backend can track SDK version usage per merchant
 
 ## [2.2.0] - 2026-05-20
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jamm (2.3.0)
+    jamm (2.4.0)
       base64 (~> 0.2)
       rest-client (~> 2.0)
       typhoeus (~> 1.0, >= 1.0.1)
@@ -24,7 +24,9 @@ GEM
       ffi (>= 1.15.0)
     faker (3.5.1)
       i18n (>= 1.8.11, < 2)
-    ffi (1.17.0)
+    ffi (1.17.0-aarch64-linux-gnu)
+    ffi (1.17.0-arm64-darwin)
+    ffi (1.17.0-x86_64-linux-gnu)
     gimei (1.5.0)
     hashdiff (1.1.0)
     http-accept (1.7.0)

data/compatibility/.gitignore

@@ -0,0 +1,11 @@
+# Per-version status emitted by `make report` for the PR comment workflow.
+compat-report.tsv
+
+# Installed published gems and per-directory bundler state -- pulled fresh from
+# the registry per run.
+*/.bundle
+*/vendor
+
+# Lockfiles are intentionally untracked: these install real published versions
+# from the registry and are out of scope for our vulnerability checks.
+*/Gemfile.lock

data/compatibility/1.3.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.3.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '1.3.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/1.3.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.3.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@1.3.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '1.3.0'
+end

data/compatibility/1.4.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.4.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '1.4.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/1.4.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.4.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@1.4.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '1.4.0'
+end

data/compatibility/1.4.1/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.4.1` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '1.4.1'
+gem 'test-unit', '~> 3.0'

data/compatibility/1.4.1/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.4.1` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@1.4.1 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '1.4.1'
+end

data/compatibility/1.5.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.5.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '1.5.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/1.5.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.5.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@1.5.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '1.5.0'
+end

data/compatibility/1.6.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.6.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '1.6.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/1.6.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.6.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@1.6.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '1.6.0'
+end

data/compatibility/1.7.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.7.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '1.7.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/1.7.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=1.7.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@1.7.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '1.7.0'
+end

data/compatibility/2.0.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.0.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '2.0.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/2.0.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.0.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@2.0.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '2.0.0'
+end

data/compatibility/2.1.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.1.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '2.1.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/2.1.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.1.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@2.1.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '2.1.0'
+end

data/compatibility/2.2.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.2.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '2.2.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/2.2.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.2.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@2.2.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '2.2.0'
+end

data/compatibility/2.3.0/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.3.0` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '2.3.0'
+gem 'test-unit', '~> 3.0'

data/compatibility/2.3.0/compat_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=2.3.0` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@2.3.0 (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '2.3.0'
+end

data/compatibility/Makefile

@@ -0,0 +1,63 @@
+.PHONY: ls install test report clean add
+
+WORKDIR := /services/packages/sdk/ruby/compatibility
+
+# Run inside the api container (same pattern as the parent SDK Makefile) so the
+# SDK's env: 'local' host (api.jamm.test) resolves to the local backend.
+ifneq ($(WORKDIR), $(PWD))
+EXEC := docker compose exec -w $(WORKDIR) api
+endif
+
+# Pinned version directories -- everything except shared/ and templates/.
+VERSIONS := $(filter-out shared/ templates/,$(wildcard */))
+
+# List the version directories under test.
+ls:
+	@echo "Compat versions:" $(VERSIONS:/=)
+
+# Install each pinned gem version into its own bundle (lockfiles are gitignored
+# on purpose). BUNDLE_GEMFILE scopes bundler to that directory's Gemfile.
+install:
+	@$(EXEC) bash -c 'set -e; for d in $(VERSIONS); do \
+		echo "== install $$d =="; \
+		( cd $$d && BUNDLE_GEMFILE=Gemfile bundle install ); \
+	done'
+
+# Run the shared suite against every pinned version. Runs all versions even if
+# one fails, then exits non-zero if any did -- so a single broken version is
+# visible without masking the rest.
+test:
+	@$(EXEC) bash -c 'rc=0; for d in $(VERSIONS); do \
+		echo "== test $$d =="; \
+		( cd $$d && \
+			MERCHANT_CLIENT_ID=$(MERCHANT_CLIENT_ID) \
+			MERCHANT_CLIENT_SECRET=$(MERCHANT_CLIENT_SECRET) \
+			BUNDLE_GEMFILE=Gemfile bundle exec ruby compat_test.rb ) || rc=1; \
+	done; exit $$rc'
+
+# CI variant of `test`: runs every version, writes per-version status to
+# compat-report.tsv ("<version>\t<PASS|FAIL>"), and always exits 0. The
+# workflow turns the file into a PR comment, so the merge is not blocked when
+# an older published version is out of sync with the current API.
+report:
+	@$(EXEC) bash -c 'rm -f compat-report.tsv; for d in $(VERSIONS); do \
+		v=$${d%/}; \
+		echo "== test $$v =="; \
+		if ( cd $$d && \
+			MERCHANT_CLIENT_ID=$(MERCHANT_CLIENT_ID) \
+			MERCHANT_CLIENT_SECRET=$(MERCHANT_CLIENT_SECRET) \
+			BUNDLE_GEMFILE=Gemfile bundle exec ruby compat_test.rb ); then status=PASS; else status=FAIL; fi; \
+		printf "%s\t%s\n" "$$v" "$$status" >> compat-report.tsv; \
+	done; echo "== summary =="; cat compat-report.tsv'
+
+# Remove installed bundles and lockfiles for every version.
+clean:
+	@for d in $(VERSIONS); do rm -rf $$d/.bundle $$d/vendor $$d/Gemfile.lock; done
+
+# Scaffold a new version directory from the templates: make add VER=2.4.0
+add:
+	@test -n "$(VER)" || { echo "usage: make add VER=x.y.z"; exit 1; }
+	@mkdir -p "$(VER)"
+	@sed 's/__VERSION__/$(VER)/g' templates/Gemfile.tmpl        > "$(VER)/Gemfile"
+	@sed 's/__VERSION__/$(VER)/g' templates/compat_test.rb.tmpl > "$(VER)/compat_test.rb"
+	@echo "Created $(VER)/ -- run 'make install' then 'make test'."

data/compatibility/README.md

@@ -0,0 +1,119 @@
+# Ruby SDK backward-compatibility tests
+
+This directory verifies that previously **published** versions of the `jamm` gem
+still work against the current API — i.e. that the SDKs and the backend stay in
+sync. The pre-release/latest SDK lives in `../lib` and is covered by
+`../test.e2e`; this directory covers the **released** versions pulled from the
+RubyGems registry.
+
+## Layout
+
+```
+packages/sdk/
+  compatibility/
+    testdata/        # language-neutral backend webhook records; shared by every SDK harness
+  ruby/compatibility/
+    shared/
+      suite.rb         # the shared, capability-gated smoke suite (single source of truth)
+    templates/         # source templates for each version directory
+    <version>/
+      Gemfile          # pins jamm@<version> + test-unit
+      compat_test.rb   # thin shim: requires the pinned gem, runs the shared suite
+    Makefile
+```
+
+Each `<version>/` directory installs its own pinned gem into its own bundle, so
+its `compat_test.rb` requires `jamm` and bundler resolves it to that directory's
+version. The shim then mixes `JammCompat::Tests` into a `Test::Unit::TestCase`,
+so the **same** assertions run against every version.
+
+Lockfiles (`Gemfile.lock`) and installed bundles are git-ignored on purpose:
+these install real published versions from the registry and are out of scope for
+our vulnerability checks.
+
+## What is tested
+
+The suite is capability-gated, because the public surface grew over time. Where a
+service is missing in an older gem, its check is omitted (skipped) rather than
+failed:
+
+| Check                          | Touches API | Notes                                             |
+| ------------------------------ | ----------- | ------------------------------------------------- |
+| `Jamm.configure` + environment | no          | environment round-trips to `local`                |
+| `Jamm::Healthcheck.ping`       | yes         | skipped unless `MERCHANT_CLIENT_*` are set         |
+| `Jamm::Webhook.verify`         | no          | recomputes the HMAC signature; asserts the contract |
+| `Jamm::Webhook.parse`          | no          | forward-compat: parses backend records carrying newer fields (see below) |
+
+### Forward-compatibility: `Jamm::Webhook.parse` against current-day records
+
+`../../compatibility/testdata/*.json` are webhook payloads shaped as the backend
+sends them, covering both shapes the harness cares about:
+
+- `charge_success_api_source.json` — a flat charge carrying `api_source`
+  (`ChargeMessage` field 23). The backend marshals webhook content with Go's
+  `json.Marshal` (not `protojson`), so the enum goes out as its numeric value
+  (`"api_source": 3`); there is no enum-string form on the wire.
+- `refund_succeeded_nested_api_source.json` — the nested refund wrapper
+  (`content.transaction` + `content.refund`) **with** `api_source`.
+- `refund_succeeded_nested_no_api_source.json` — the same nested wrapper
+  **without** `api_source` (older backends, or charges created outside the charge
+  API), which must also parse, resolving to the model's default.
+
+The suite asserts every parse-capable version **must** decode the core
+`ChargeMessage` (`id`, `customer`) and ignore fields it predates. A version that
+*has* `parse` but throws on these records **fails** the test — that failure is the
+signal it is out of sync with the API, not an accepted outcome (mirrors the Node
+harness).
+
+> [!IMPORTANT]
+> The `api_source` / nested-refund webhook feature was **rolled back on `main`**
+> for release (PR #2316, reverting #2304/#2281/#2282/…). As of that revert the
+> backend does **not** emit `api_source` in charge webhooks and the latest SDK
+> source (`../lib`, currently `2.2.0`) has no forward-compat parse. These fixtures
+> are retained deliberately — covering both the with- and without-`api_source`
+> shapes — so this harness is the ready-made signal for which published versions
+> tolerate the contract once it re-lands.
+
+Expected behavior across the pinned versions, from each gem's CHANGELOG (the
+authoritative matrix is whatever `make test` reports against the installed gems):
+
+| version        | nested refund wrapper | `api_source` resolution | expected parse result                                  |
+| -------------- | --------------------- | ----------------------- | ------------------------------------------------------ |
+| 1.3.0 – 1.7.0  | no                    | no                      | refund events unhandled → `parse` raises (out of sync) |
+| 2.0.0 – 2.2.0  | partial               | no                      | strict decode throws on `api_source` (out of sync)     |
+| 2.3.0          | yes                   | yes                     | ✅ decodes core fields, ignores/resolves newer fields  |
+
+Verified locally: the suite passes 100% against a forward-compat-capable SDK
+source and fails the three `parse` fixtures against the reverted `2.2.0` source —
+i.e. the harness flags out-of-sync versions exactly as intended.
+
+## Running
+
+Pinned versions are installed from the registry; the live `healthcheck` check
+talks to the local backend (`api.jamm.test`), so the suite runs inside the `api`
+container like the parent SDK's e2e tests.
+
+```sh
+# from packages/sdk/ruby/compatibility
+make install                 # install all pinned versions
+make test \
+  MERCHANT_CLIENT_ID=...  \
+  MERCHANT_CLIENT_SECRET=... # run the suite against every version
+```
+
+Without credentials the offline checks still run and the live `healthcheck`
+check is skipped.
+
+## Pinned versions
+
+The latest 10 versions published to the RubyGems registry (the installable
+source of truth): `1.3.0, 1.4.0, 1.4.1, 1.5.0, 1.6.0, 1.7.0, 2.0.0, 2.1.0,
+2.2.0, 2.3.0`. The registry and the GitHub tags can disagree — pin to what
+RubyGems actually serves, since that is what merchants install.
+
+To add a newly released version:
+
+```sh
+make add VER=2.4.0           # scaffolds 2.4.0/ from templates/
+make install && make test
+```

data/compatibility/shared/suite.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'openssl'
+require 'test/unit'
+
+# Shared backward-compatibility smoke suite for the published `jamm` gem.
+#
+# Each compatibility/<version>/ directory pins and installs its own published gem
+# version (via its sibling Gemfile), then its compat_test.rb shim builds a
+# Test::Unit::TestCase that `include`s JammCompat::Tests. Pinning happens through
+# bundler, so `require 'jamm'` in that process resolves to *this* directory's
+# version and the same assertions run against every version.
+#
+# The suite is capability-gated: the public surface grew across versions, so a
+# check for a service that did not exist yet is omitted (skipped) rather than
+# failed. The one deliberate exception is webhook.parse -- see PARSE_FIXTURES.
+module JammCompat
+  # Shared decoded-core assertions: every parse-capable version must decode these
+  # from each fixture regardless of the newer fields it carries.
+  EXPECTED = { id: 'trx-00000000000000000000', customer: 'cus-00000000000000000000' }.freeze
+
+  # Backend webhook records shaped exactly as the current API emits them (see
+  # packages/sdk/compatibility/testdata/), carrying fields newer than most published gems: api_source
+  # (ChargeMessage field 23) and the nested { transaction, refund } refund
+  # wrapper. The backend marshals webhook content with Go's json.Marshal (not
+  # protojson), so enums go out numeric ("api_source": 3) -- there is no
+  # enum-string form on the wire, so one fixture per record shape is enough.
+  # Each charge/refund shape is covered both with and without api_source so the
+  # post-revert backend (no api_source emitted) is exercised alongside the
+  # re-landed-feature shape.
+  PARSE_FIXTURES = [
+    { file: 'charge_success_api_source.json', event: 'CHARGE_SUCCESS + api_source' },
+    { file: 'charge_success_without_api_source.json', event: 'CHARGE_SUCCESS, no api_source' },
+    { file: 'refund_succeeded_nested_api_source.json', event: 'REFUND_SUCCEEDED, nested wrapper + api_source' },
+    { file: 'refund_succeeded_nested_no_api_source.json', event: 'REFUND_SUCCEEDED, nested wrapper, no api_source' }
+  ].freeze
+
+  # Payload for the webhook.verify contract check. The signature is NOT hardcoded:
+  # verify() HMAC-signs JSON.dump(data) with the configured client_secret, so the
+  # suite recomputes the expected signature for whatever secret it configured.
+  # Fixed pseudo IDs, not real merchant data.
+  WEBHOOK_DATA = {
+    customer: 'cus-000000000000000000',
+    created_at: '2024-11-29T02:16:12.168127Z',
+    activated_at: '2024-11-29T02:16:18.040142301Z',
+    merchant_name: 'TestMerchant1'
+  }.freeze
+
+  # Mirrors the e2e credential env vars. When unset, the live-API healthcheck is
+  # skipped so the offline checks still run (e.g. in CI without a reachable backend).
+  CLIENT_ID = ENV['MERCHANT_CLIENT_ID'] || 'compat-client-id'
+  CLIENT_SECRET = ENV['MERCHANT_CLIENT_SECRET'] || 'compat-client-secret'
+  HAS_API_CREDS = !(ENV['MERCHANT_CLIENT_ID'].to_s.empty? || ENV['MERCHANT_CLIENT_SECRET'].to_s.empty?)
+
+  # Fixtures live in the language-neutral packages/sdk/compatibility/testdata/
+  # directory so every SDK harness consumes the same backend records.
+  def self.testdata_path(file)
+    File.join(__dir__, '..', '..', '..', 'compatibility', 'testdata', file)
+  end
+
+  # The actual checks. A version directory's shim mixes this into a
+  # Test::Unit::TestCase, so test/unit auto-discovers every `test_*` method.
+  module Tests
+    def load_fixture(file)
+      JSON.parse(File.read(JammCompat.testdata_path(file)), symbolize_names: true)
+    end
+
+    def configure!
+      Jamm.configure(
+        client_id: JammCompat::CLIENT_ID,
+        client_secret: JammCompat::CLIENT_SECRET,
+        env: 'local'
+      )
+    end
+
+    # config -- expected in every published version.
+    def test_config_round_trips_local_environment
+      omit('Jamm.configure absent in this version') unless Jamm.respond_to?(:configure)
+      configure!
+      omit('Jamm.environment reader absent in this version') unless Jamm.respond_to?(:environment)
+      assert_equal('local', Jamm.environment)
+    end
+
+    # healthcheck -- hits the live local API (api.jamm.test), so it needs creds and
+    # a reachable backend; skipped otherwise.
+    def test_healthcheck_pings_api
+      unless defined?(Jamm::Healthcheck) && Jamm::Healthcheck.respond_to?(:ping)
+        omit('healthcheck service absent in this version')
+      end
+      omit('MERCHANT_CLIENT_* not set; live API check skipped') unless JammCompat::HAS_API_CREDS
+
+      configure!
+      res = Jamm::Healthcheck.ping
+      assert_not_nil(res)
+      assert_true(res.ok)
+    end
+
+    # webhook.verify -- offline signing-contract check: recompute the signature the
+    # SDK expects, confirm verify() accepts it, then confirm a tampered (but
+    # well-formed) signature is rejected.
+    def test_webhook_verify_accepts_valid_and_rejects_tampered
+      unless defined?(Jamm::Webhook) && Jamm::Webhook.respond_to?(:verify)
+        omit('webhook.verify absent in this version')
+      end
+
+      configure!
+      digest = OpenSSL::HMAC.hexdigest(
+        OpenSSL::Digest.new('sha256'),
+        JammCompat::CLIENT_SECRET,
+        JSON.dump(JammCompat::WEBHOOK_DATA)
+      )
+
+      assert_nothing_raised do
+        Jamm::Webhook.verify(data: JammCompat::WEBHOOK_DATA, signature: "sha256=#{digest}")
+      end
+
+      assert_raise do
+        Jamm::Webhook.verify(data: JammCompat::WEBHOOK_DATA, signature: "sha256=#{'0' * 64}")
+      end
+    end
+
+    # webhook.parse forward-compat -- pretends the backend is sending current-day
+    # records that carry api_source and the nested refund wrapper. Every
+    # parse-capable version MUST decode the core ChargeMessage and ignore fields it
+    # predates.
+    #
+    # NOTE: there is intentionally no rescue here. A version that *has* parse but
+    # throws on these records is out of sync with the API -- that failure is the
+    # signal, not an accepted outcome (mirrors the Node harness, where only the
+    # latest version passes). Only a version with no parse capability at all is
+    # omitted.
+    JammCompat::PARSE_FIXTURES.each do |fx|
+      slug = fx[:file].sub(/\.json\z/, '')
+      define_method("test_webhook_parse_tolerates_#{slug}") do
+        unless defined?(Jamm::Webhook) && Jamm::Webhook.respond_to?(:parse)
+          omit('webhook.parse absent in this version')
+        end
+
+        msg = Jamm::Webhook.parse(load_fixture(fx[:file]))
+        assert_equal(JammCompat::EXPECTED[:id], msg.content.id, fx[:event])
+        assert_equal(JammCompat::EXPECTED[:customer], msg.content.customer, fx[:event])
+      end
+    end
+  end
+end

data/compatibility/templates/Gemfile.tmpl

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Generated from templates/Gemfile.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=__VERSION__` from packages/sdk/ruby/compatibility.
+source 'https://rubygems.org'
+
+gem 'jamm', '__VERSION__'
+gem 'test-unit', '~> 3.0'

data/compatibility/templates/compat_test.rb.tmpl

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Generated from templates/compat_test.rb.tmpl -- do not edit by hand.
+# Regenerate with `make add VER=__VERSION__` from packages/sdk/ruby/compatibility.
+#
+# Installs the published jamm@__VERSION__ (pinned in the sibling Gemfile) and runs
+# the shared backward-compat suite against it. Requiring 'jamm' here -- under this
+# directory's bundle -- is what makes bundler resolve it to *this* pinned version.
+require 'jamm'
+
+require_relative '../shared/suite'
+
+class CompatTest < Test::Unit::TestCase
+  include JammCompat::Tests
+
+  SDK_VERSION = '__VERSION__'
+end

data/lib/jamm/api/models/v1_charge_message.rb

@@ -62,8 +62,6 @@ module Api
 
     attr_accessor :refund
 
-    attr_accessor :api_source
-
     class EnumAttributeValidator
       attr_reader :datatype
       attr_reader :allowable_values
@@ -107,8 +105,7 @@ module Api
         :'consumption_tax' => :'consumptionTax',
         :'error' => :'error',
         :'refund_id' => :'refundId',
-        :'refund' => :'refund',
-        :'api_source' => :'apiSource'
+        :'refund' => :'refund'
       }
     end
 
@@ -138,8 +135,7 @@ module Api
         :'consumption_tax' => :'Integer',
         :'error' => :'Apiv1Error',
         :'refund_id' => :'String',
-        :'refund' => :'RefundInfo',
-        :'api_source' => :'ChargeMessageApiSource'
+        :'refund' => :'RefundInfo'
       }
     end
 
@@ -241,12 +237,6 @@ module Api
       if attributes.key?(:'refund')
         self.refund = attributes[:'refund']
       end
-
-      if attributes.key?(:'api_source')
-        self.api_source = attributes[:'api_source']
-      else
-        self.api_source = 'API_SOURCE_UNSPECIFIED'
-      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -287,8 +277,7 @@ module Api
           consumption_tax == o.consumption_tax &&
           error == o.error &&
           refund_id == o.refund_id &&
-          refund == o.refund &&
-          api_source == o.api_source
+          refund == o.refund
     end
 
     # @see the `==` method
@@ -300,7 +289,7 @@ module Api
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [id, customer, status, description, merchant_name, initial_amount, discount, final_amount, amount_refunded, currency, processed_at, jamm_fee, created_at, updated_at, original_transaction_jamm_fee, consumption_tax, error, refund_id, refund, api_source].hash
+      [id, customer, status, description, merchant_name, initial_amount, discount, final_amount, amount_refunded, currency, processed_at, jamm_fee, created_at, updated_at, original_transaction_jamm_fee, consumption_tax, error, refund_id, refund].hash
     end
 
     # Builds the object from hash

data/lib/jamm/api/models/v1_error_type.rb

@@ -38,6 +38,7 @@ module Api
     PAYMENT_CUSTOMER_NOT_FOUND = "ERROR_TYPE_PAYMENT_CUSTOMER_NOT_FOUND".freeze
     PAYMENT_CUSTOMER_INACTIVE = "ERROR_TYPE_PAYMENT_CUSTOMER_INACTIVE".freeze
     PAYMENT_SERVICE_DISABLED = "ERROR_TYPE_PAYMENT_SERVICE_DISABLED".freeze
+    PAYMENT_BANK_UNAVAILABLE = "ERROR_TYPE_PAYMENT_BANK_UNAVAILABLE".freeze
     CSV_VALIDATION_FAILED = "ERROR_TYPE_CSV_VALIDATION_FAILED".freeze
     CSV_TOTP_REQUIRED = "ERROR_TYPE_CSV_TOTP_REQUIRED".freeze
     CSV_TOTP_INVALID = "ERROR_TYPE_CSV_TOTP_INVALID".freeze
@@ -55,7 +56,7 @@ module Api
     TOTP_DISABLE_FAILED = "ERROR_TYPE_TOTP_DISABLE_FAILED".freeze
 
     def self.all_vars
-      @all_vars ||= [UNSPECIFIED, AUTH_FAILED, AUTH_REJECTED, ACCOUNT_CREATION_FAILED, ACCOUNT_MODIFICATION_FAILED, ACCOUNT_DELETION_FAILED, ACCOUNT_BANK_REGISTRATION_FAILED, KYC_REJECTED, NOTIFICATION_WEBHOOK_FAILED, NOTIFICATION_EMAIL_FAILED, NOTIFICATION_SMS_FAILED, PAYMENT_GATEWAY_UNAVAILABLE, PAYMENT_GATEWAY_FAILED, PAYMENT_VALIDATION_FAILED, PAYMENT_CHARGE_FAILED, PAYMENT_CHARGE_REJECTED, PAYMENT_CHARGE_OVER_LIMIT, PAYMENT_CHARGE_SUBSCRIPTION_EXPIRED, PAYMENT_LINK_EXPIRED, PAYMENT_CHARGE_INSUFFICIENT_FUNDS, PAYMENT_CUSTOMER_NOT_FOUND, PAYMENT_CUSTOMER_INACTIVE, PAYMENT_SERVICE_DISABLED, CSV_VALIDATION_FAILED, CSV_TOTP_REQUIRED, CSV_TOTP_INVALID, CSV_TOTP_EXPIRED, CSV_TOTP_LOCKED, CSV_BATCH_TOO_LARGE, CSV_CUSTOMER_NOT_FOUND, CSV_PROCESSING_FAILED, CSV_CHALLENGE_NOT_FOUND, CSV_DUPLICATE_USER, TOTP_SETUP_FAILED, TOTP_ALREADY_ENABLED, TOTP_NOT_ENABLED, TOTP_SETUP_INVALID, TOTP_DISABLE_FAILED].freeze
+      @all_vars ||= [UNSPECIFIED, AUTH_FAILED, AUTH_REJECTED, ACCOUNT_CREATION_FAILED, ACCOUNT_MODIFICATION_FAILED, ACCOUNT_DELETION_FAILED, ACCOUNT_BANK_REGISTRATION_FAILED, KYC_REJECTED, NOTIFICATION_WEBHOOK_FAILED, NOTIFICATION_EMAIL_FAILED, NOTIFICATION_SMS_FAILED, PAYMENT_GATEWAY_UNAVAILABLE, PAYMENT_GATEWAY_FAILED, PAYMENT_VALIDATION_FAILED, PAYMENT_CHARGE_FAILED, PAYMENT_CHARGE_REJECTED, PAYMENT_CHARGE_OVER_LIMIT, PAYMENT_CHARGE_SUBSCRIPTION_EXPIRED, PAYMENT_LINK_EXPIRED, PAYMENT_CHARGE_INSUFFICIENT_FUNDS, PAYMENT_CUSTOMER_NOT_FOUND, PAYMENT_CUSTOMER_INACTIVE, PAYMENT_SERVICE_DISABLED, PAYMENT_BANK_UNAVAILABLE, CSV_VALIDATION_FAILED, CSV_TOTP_REQUIRED, CSV_TOTP_INVALID, CSV_TOTP_EXPIRED, CSV_TOTP_LOCKED, CSV_BATCH_TOO_LARGE, CSV_CUSTOMER_NOT_FOUND, CSV_PROCESSING_FAILED, CSV_CHALLENGE_NOT_FOUND, CSV_DUPLICATE_USER, TOTP_SETUP_FAILED, TOTP_ALREADY_ENABLED, TOTP_NOT_ENABLED, TOTP_SETUP_INVALID, TOTP_DISABLE_FAILED].freeze
     end
 
     # Builds the enum from string

data/lib/jamm/api/models/v1_refund_info.rb

@@ -17,7 +17,7 @@ module Api
   # RefundInfo contains refund-specific details for refund and refund_failed webhook events.
   class RefundInfo
     # External refund identifier (rfd-*).
-    attr_accessor :id
+    attr_accessor :refund_id
 
     # Amount refunded for this event.
     attr_accessor :amount_refunded
@@ -39,7 +39,7 @@ module Api
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
-        :'id' => :'id',
+        :'refund_id' => :'refundId',
         :'amount_refunded' => :'amountRefunded',
         :'jamm_fee' => :'jammFee',
         :'consumption_tax' => :'consumptionTax',
@@ -57,7 +57,7 @@ module Api
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'id' => :'String',
+        :'refund_id' => :'String',
         :'amount_refunded' => :'Integer',
         :'jamm_fee' => :'Integer',
         :'consumption_tax' => :'Integer',
@@ -88,8 +88,8 @@ module Api
         h[k.to_sym] = v
       }
 
-      if attributes.key?(:'id')
-        self.id = attributes[:'id']
+      if attributes.key?(:'refund_id')
+        self.refund_id = attributes[:'refund_id']
       end
 
       if attributes.key?(:'amount_refunded')
@@ -137,7 +137,7 @@ module Api
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          id == o.id &&
+          refund_id == o.refund_id &&
           amount_refunded == o.amount_refunded &&
           jamm_fee == o.jamm_fee &&
           consumption_tax == o.consumption_tax &&
@@ -155,7 +155,7 @@ module Api
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [id, amount_refunded, jamm_fee, consumption_tax, original_transaction_fee_waived, error, processed_at].hash
+      [refund_id, amount_refunded, jamm_fee, consumption_tax, original_transaction_fee_waived, error, processed_at].hash
     end
 
     # Builds the object from hash

data/lib/jamm/api.rb

@@ -19,7 +19,6 @@ require 'jamm/api/configuration'
 # Models
 require 'jamm/api/models/apiv1_error'
 require 'jamm/api/models/apiv1_status'
-require 'jamm/api/models/charge_message_api_source'
 require 'jamm/api/models/customer_service_update_customer_body'
 require 'jamm/api/models/googlerpc_status'
 require 'jamm/api/models/protobuf_any'

data/lib/jamm/client.rb

@@ -9,6 +9,7 @@ module Jamm
       base.config.host = Jamm.openapi.config.host
       base.config.scheme = Jamm.openapi.config.scheme
       base.default_headers['Authorization'] = "Bearer #{Jamm::OAuth.token}"
+      base.default_headers['X-SDK-Version'] = "ruby:#{Jamm::VERSION}"
 
       # Platform feature, optionally set merchant id to call Jamm API
       # on behalf of the merchant.

data/lib/jamm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jamm
-  VERSION = '2.3.0'
+  VERSION = '2.4.0'
 end

data/lib/jamm/webhook.rb

@@ -11,157 +11,39 @@ module Jamm
     # Parse command is for parsing the received webhook message.
     # It does not call anything remotely, instead returns the suitable object.
     def self.parse(json)
-      # Webhook payloads may arrive with string or symbol keys depending on how
-      # the caller decoded the JSON (e.g. JSON.parse with or without
-      # symbolize_names: true). Normalize to symbols so event-type routing,
-      # wrapper flattening, and field lookups are reliable either way.
-      json = deep_symbolize_keys(json)
-
-      out = build(Jamm::OpenAPI::MerchantWebhookMessage, json)
+      out = Jamm::OpenAPI::MerchantWebhookMessage.new(json)
 
       case json[:event_type]
-      when Jamm::OpenAPI::EventType::CHARGE_CREATED,
-           Jamm::OpenAPI::EventType::CHARGE_UPDATED,
-           Jamm::OpenAPI::EventType::REFUND_SUCCEEDED,
-           Jamm::OpenAPI::EventType::REFUND_FAILED,
-           Jamm::OpenAPI::EventType::CHARGE_SUCCESS,
-           Jamm::OpenAPI::EventType::CHARGE_FAIL
-        out.content = build(Jamm::OpenAPI::ChargeMessage, flatten_charge_content(json[:content]))
+      when Jamm::OpenAPI::EventType::CHARGE_CREATED
+        out.content = Jamm::OpenAPI::ChargeMessage.new(json[:content])
         return out
 
-      when Jamm::OpenAPI::EventType::CONTRACT_ACTIVATED
-        out.content = build(Jamm::OpenAPI::ContractMessage, json[:content])
+      when Jamm::OpenAPI::EventType::CHARGE_UPDATED
+        out.content = Jamm::OpenAPI::ChargeMessage.new(json[:content])
         return out
 
-      when Jamm::OpenAPI::EventType::USER_ACCOUNT_DELETED
-        out.content = build(Jamm::OpenAPI::UserAccountMessage, json[:content])
+      when Jamm::OpenAPI::EventType::REFUND_SUCCEEDED
+        out.content = Jamm::OpenAPI::ChargeMessage.new(json[:content])
         return out
-      end
-
-      raise 'Unknown event type'
-    end
 
-    # Build a generated model from a webhook payload while normalizing the
-    # quirks of the webhook wire format. Applied to every model, so charges,
-    # contracts, user-account and refund messages all benefit:
-    #
-    #   1. Forward-compat: the Jamm backend can add new fields to webhook
-    #      payloads at any time. The generated model `initialize` raises
-    #      ArgumentError on any key outside `attribute_map`, so unknown keys are
-    #      dropped first. Known keys are snake_case, matching `attribute_map`.
-    #   2. Numeric enums: the backend serializes webhook payloads with Go's
-    #      `json.Marshal` (not protojson), so every enum field (status,
-    #      api_source, ...) arrives as its integer value, while the generated
-    #      enums are string-based. Each integer is mapped back to the enum string
-    #      so it matches the values returned by the REST API.
-    #   3. Nested models: the generated `initialize` assigns nested objects
-    #      verbatim (the `_deserialize` coercion only runs from `build_from_hash`,
-    #      which expects camelCase keys the webhook does not use). So a nested
-    #      field like `refund.error` would stay a raw Hash and `error.code` would
-    #      raise NoMethodError. We coerce nested model fields (and arrays of them)
-    #      recursively so the typed accessors work.
-    def self.build(klass, attributes)
-      return nil if attributes.nil?
-
-      known = klass.attribute_map
-      types = klass.openapi_types
-      filtered = attributes.each_with_object({}) do |(key, value), acc|
-        sym = key.to_sym
-        next unless known.key?(sym)
-
-        acc[sym] = coerce(types[sym], value)
-      end
+      when Jamm::OpenAPI::EventType::REFUND_FAILED
+        out.content = Jamm::OpenAPI::ChargeMessage.new(json[:content])
+        return out
 
-      klass.new(filtered)
-    end
+      when Jamm::OpenAPI::EventType::CHARGE_SUCCESS
+        out.content = Jamm::OpenAPI::ChargeMessage.new(json[:content])
+        return out
 
-    # Refund webhooks (REFUND_SUCCEEDED / REFUND_FAILED) deliver `content` as a
-    # nested { transaction, refund } wrapper instead of a flat ChargeMessage.
-    # Flatten it back into a ChargeMessage so callers always receive the same shape.
-    def self.flatten_charge_content(content)
-      return content unless content.is_a?(Hash) && content.key?(:transaction)
-
-      refund = content[:refund]
-      # Keep `refund` as the raw Hash: `build` coerces it into a typed RefundInfo
-      # (and recursively types its nested `error`). Also surface the refund's
-      # `rfd-` id on the flat `refund_id` attribute the model documents.
-      charge = content[:transaction].merge(refund: refund)
-      charge[:refund_id] = refund[:id] if refund.is_a?(Hash) && !refund[:id].nil?
-      charge
-    end
+      when Jamm::OpenAPI::EventType::CHARGE_FAIL
+        out.content = Jamm::OpenAPI::ChargeMessage.new(json[:content])
+        return out
 
-    # Coerce a raw webhook value into the shape the generated model expects,
-    # based on the field's openapi type: numeric enums become their string
-    # constant, nested models become typed instances, and `Array<T>` elements are
-    # coerced by `T`. Anything else passes through untouched.
-    def self.coerce(type, value)
-      return value if value.nil?
-
-      inner = array_inner_type(type)
-      return coerce_array(inner, value) unless inner.nil?
-
-      klass = openapi_const(type)
-      return value if klass.nil?
-
-      if klass.respond_to?(:all_vars)
-        resolve_enum(klass, value)
-      elsif klass.respond_to?(:openapi_types) && value.is_a?(Hash)
-        build(klass, value)
-      else
-        value
+      when Jamm::OpenAPI::EventType::CONTRACT_ACTIVATED
+        out.content = Jamm::OpenAPI::ContractMessage.new(json[:content])
+        return out
       end
-    end
 
-    # Coerce each element of an `Array<T>` field by its inner type `T`.
-    def self.coerce_array(inner_type, value)
-      return value unless value.is_a?(Array)
-
-      value.map { |element| coerce(inner_type, element) }
-    end
-
-    # Extract `T` from an `Array<T>` openapi type, or nil when not an array type.
-    def self.array_inner_type(type)
-      match = type.to_s.match(/\AArray<(.+)>\z/)
-      match && match[1]
-    end
-
-    # Map a numeric enum wire value onto its string enum constant. A value that
-    # is already a string (REST-style) passes through untouched.
-    def self.resolve_enum(enum, value)
-      return value unless value.is_a?(Integer)
-
-      vars = enum.all_vars
-      # Guard the bounds explicitly: Ruby maps negative indices from the end of
-      # the array, so any unexpected wire value must fall back to the *_UNSPECIFIED
-      # member (index 0) rather than silently selecting the wrong constant.
-      value.between?(0, vars.length - 1) ? vars[value] : vars[0]
-    end
-
-    # Resolve an openapi_types entry (e.g. :ChargeMessageApiSource, :RefundInfo)
-    # to its generated class, or nil when the type is a primitive (String,
-    # Integer, ...) or otherwise unresolvable.
-    def self.openapi_const(type)
-      return nil if type.nil?
-
-      name = type.to_s
-      return nil unless Jamm::OpenAPI.const_defined?(name)
-
-      Jamm::OpenAPI.const_get(name)
-    rescue NameError
-      nil
-    end
-
-    # Recursively convert Hash keys to symbols so parsing is robust regardless of
-    # how the caller decoded the webhook JSON.
-    def self.deep_symbolize_keys(value)
-      case value
-      when Hash
-        value.each_with_object({}) { |(k, v), acc| acc[k.to_sym] = deep_symbolize_keys(v) }
-      when Array
-        value.map { |v| deep_symbolize_keys(v) }
-      else
-        value
-      end
+      raise 'Unknown event type'
     end
 
     # Verify message.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jamm
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Jamm
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-24 00:00:00.000000000 Z
+date: 2026-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -72,6 +72,32 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- compatibility/.gitignore
+- compatibility/1.3.0/Gemfile
+- compatibility/1.3.0/compat_test.rb
+- compatibility/1.4.0/Gemfile
+- compatibility/1.4.0/compat_test.rb
+- compatibility/1.4.1/Gemfile
+- compatibility/1.4.1/compat_test.rb
+- compatibility/1.5.0/Gemfile
+- compatibility/1.5.0/compat_test.rb
+- compatibility/1.6.0/Gemfile
+- compatibility/1.6.0/compat_test.rb
+- compatibility/1.7.0/Gemfile
+- compatibility/1.7.0/compat_test.rb
+- compatibility/2.0.0/Gemfile
+- compatibility/2.0.0/compat_test.rb
+- compatibility/2.1.0/Gemfile
+- compatibility/2.1.0/compat_test.rb
+- compatibility/2.2.0/Gemfile
+- compatibility/2.2.0/compat_test.rb
+- compatibility/2.3.0/Gemfile
+- compatibility/2.3.0/compat_test.rb
+- compatibility/Makefile
+- compatibility/README.md
+- compatibility/shared/suite.rb
+- compatibility/templates/Gemfile.tmpl
+- compatibility/templates/compat_test.rb.tmpl
 - jamm.gemspec
 - lib/jamm.rb
 - lib/jamm/api.rb
@@ -84,7 +110,6 @@ files:
 - lib/jamm/api/configuration.rb
 - lib/jamm/api/models/apiv1_error.rb
 - lib/jamm/api/models/apiv1_status.rb
-- lib/jamm/api/models/charge_message_api_source.rb
 - lib/jamm/api/models/customer_service_update_customer_body.rb
 - lib/jamm/api/models/googlerpc_status.rb
 - lib/jamm/api/models/protobuf_any.rb

data/lib/jamm/api/models/charge_message_api_source.rb

@@ -1,42 +0,0 @@
-=begin
-#Jamm API
-
-#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
-
-The version of the OpenAPI document: 1.0
-
-Generated by: https://openapi-generator.tech
-Generator version: 7.9.0
-
-=end
-
-require 'date'
-require 'time'
-
-module Api
-  class ChargeMessageApiSource
-    UNSPECIFIED = "API_SOURCE_UNSPECIFIED".freeze
-    OFF_SESSION_SYNC = "API_SOURCE_OFF_SESSION_SYNC".freeze
-    OFF_SESSION_ASYNC = "API_SOURCE_OFF_SESSION_ASYNC".freeze
-    ON_SESSION = "API_SOURCE_ON_SESSION".freeze
-
-    def self.all_vars
-      @all_vars ||= [UNSPECIFIED, OFF_SESSION_SYNC, OFF_SESSION_ASYNC, ON_SESSION].freeze
-    end
-
-    # Builds the enum from string
-    # @param [String] The enum value in the form of the string
-    # @return [String] The enum value
-    def self.build_from_hash(value)
-      new.build_from_hash(value)
-    end
-
-    # Builds the enum from string
-    # @param [String] The enum value in the form of the string
-    # @return [String] The enum value
-    def build_from_hash(value)
-      return value if ChargeMessageApiSource.all_vars.include?(value)
-      raise "Invalid ENUM value #{value} for class #ChargeMessageApiSource"
-    end
-  end
-end