shipeasy-sdk 3.6.0 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad9abca98f87069daf53c2e2347e9f2975595b437576738aef381fbc2a4a9a10
-  data.tar.gz: 300a69f50db74da6279666d9d6d8698dbb22d08365e846f20403609e001ea638
+  metadata.gz: c492371b226e15657ecdbdafdab11e79cd512d4f46ae412af3b000a203c0f3ec
+  data.tar.gz: a10503e08343510e5b12ebb3c23e9cdc19f05cb5781edb5fac381d7c98f8bc78
 SHA512:
-  metadata.gz: cfb4185054243325d9130de44d40fff6d28af91ee2100150a7f594c2a9925c8ab20f931a2d1ccb433b830521ac07b7ff2381ff2325cf3b1ada0591d674f30c0d
-  data.tar.gz: 5b89a4b38c9f6b9eebc9946e50ebd74bbfb5336c0354cee43321b7ea94652fff7da669deebf74317a7aee6492db6760e471ea29b0c375885474e5ab2e37fbdab
+  metadata.gz: 8df684d6629ee574b6e20bbac97c1409b56c00892c739357b980f298203cc7dc7fe1b34bce3f5758e983354c19124a648f1078f4e27bdcc9e383cef5aba5706c
+  data.tar.gz: ca4ff0fcfceca63eaad68696f5e19168b07ca559530adb42747ec9f1138d12750e694b40025094ec0b97952b73bb6dd1d784dc94a3f0669b538693260ed9cf97

data/docs/skill/SKILL.md

@@ -145,8 +145,9 @@ into every see() report later in the same (fiber-local, per-request) scope.
 <h1><%= i18n_t("hero.title", name: current_user.name) %></h1>
 ```
 
-Outside Rails: `Shipeasy.i18n_script_tag(client_key, profile: "en:prod")` emits
-the loader tag (public client key).
+Anywhere (Rails or not): `<%= Shipeasy.i18n_script_tag %>` emits the loader tag
+(public client key). Every argument is optional — key, profile and CDN base come
+from `configure`; pass one only to override it for that tag.
 
 → More: `pages/i18n.md` · snippets `snippets/i18n/{setup,render}.md`.
 
@@ -157,7 +158,10 @@ the loader tag (public client key).
 - `c.private_attributes = ["email"]` strips keys from outbound events.
 - `c.clean_backtrace` (default on) filters `see()` stacks to app frames via `Rails.backtrace_cleaner`; set `false` for raw backtraces.
 - `c.sticky_store = Shipeasy::SDK::InMemoryStickyStore.new` pins experiment assignment.
-- SSR: `Shipeasy.bootstrap_script_tag(user)` + `Shipeasy.i18n_script_tag(client_key, "en:prod")`.
+- SSR tags — all arguments optional (defaults from `configure`), html_safe under Rails:
+  `Shipeasy.bootstrap_script_tag(user)`, `Shipeasy.i18n_script_tag`,
+  `Shipeasy.devtools_script_tag` (overlay; needs `c.project_id` + `c.public_key`;
+  opens with Shift+Alt+S or `?se=1`).
 - `Shipeasy.on_change { ... }` (requires `c.poll = true`) fires after a poll fetches new data.
 
 → More: `pages/advanced.md`.

data/lib/generators/shipeasy/install/install_generator.rb

@@ -55,7 +55,7 @@ module Shipeasy
         say "  Shipeasy installed → config/initializers/shipeasy.rb", :green
         say ""
         say "  Next steps:"
-        say "    1. Mint your keys: https://app.shipeasy.ai → Settings → SDK keys"
+        say "    1. Mint your keys: https://shipeasy.ai → Connect → SDK Keys"
         say "    2. Provide them (pick one):"
         say "         • ENV — set SHIPEASY_SERVER_KEY#{options[:i18n] ? " and SHIPEASY_CLIENT_KEY" : ""}"
         say "         • Rails credentials — bin/rails credentials:edit, then read"

data/lib/shipeasy/config.rb

@@ -86,9 +86,15 @@ module Shipeasy
     attr_accessor :attributes
 
     # ---- i18n / string manager ----
-    attr_accessor :public_key, :profile, :default_chunk,
+    attr_accessor :public_key, :profile,
                   :cdn_base_url, :loader_url,
-                  :manifest_cache_ttl, :label_file_cache_ttl, :http_timeout
+                  :label_file_cache_ttl, :http_timeout
+
+    # Your Shipeasy project id (`proj_…`). Read by the SSR tag helpers — the
+    # devtools overlay tag needs it to know which project it is wired to — so
+    # setting it here is what makes `Shipeasy.devtools_script_tag` an
+    # argument-free call.
+    attr_accessor :project_id
 
     # When true, `i18n_t` renders the translation KEY verbatim instead of
     # resolving its value, so tests/snapshots assert against stable data instead
@@ -114,11 +120,12 @@ module Shipeasy
       @sticky_store         = nil
       @log_level            = :warn
 
+      @project_id           = nil
       @profile              = "default"
-      @default_chunk        = "index"
-      @cdn_base_url         = "https://cdn.i18n.shipeasy.ai"
-      @loader_url           = "https://cdn.i18n.shipeasy.ai/loader.js"
-      @manifest_cache_ttl   = 60
+      # The single CDN host the worker actually serves i18n from. The historical
+      # `cdn.i18n.shipeasy.ai` manifest host was never wired up.
+      @cdn_base_url         = "https://cdn.shipeasy.ai"
+      @loader_url           = "https://cdn.shipeasy.ai/sdk/i18n/loader.js"
       @label_file_cache_ttl = 3600
       @http_timeout         = 1
       # nil ⇒ env-derived (on under RAILS_ENV/…=="test"); true/false overrides.
@@ -306,18 +313,33 @@ module Shipeasy
     end
 
     # SSR tag helpers — delegate to the configured global engine, so you never
-    # touch it. i18n_script_tag carries the PUBLIC client key (not the server
-    # key); bootstrap_script_tag embeds no key.
-    def i18n_script_tag(client_key, profile: "en:prod", base_url: nil)
+    # touch it. i18n_script_tag and devtools_script_tag carry the PUBLIC client
+    # key (never the server key); bootstrap_script_tag embeds no key.
+    #
+    # EVERY argument is optional: each falls back to what `Shipeasy.configure`
+    # already set (public_key / project_id / profile / cdn_base_url), so the
+    # normal call is the bare helper — `<%= Shipeasy.i18n_script_tag %>`. Pass an
+    # argument only to override the configured value for one tag. The returned
+    # tag is html_safe under Rails, so no `.html_safe` at the callsite.
+    def i18n_script_tag(client_key = nil, profile: nil, base_url: nil)
       require_engine("i18n_script_tag").i18n_script_tag(client_key, profile: profile, base_url: base_url)
     end
 
-    def bootstrap_script_tag(user, anon_id: nil, i18n_profile: "en:prod", base_url: nil)
+    def bootstrap_script_tag(user = nil, anon_id: nil, i18n_profile: nil, base_url: nil)
       require_engine("bootstrap_script_tag").bootstrap_script_tag(
         user, anon_id: anon_id, i18n_profile: i18n_profile, base_url: base_url
       )
     end
 
+    # The devtools overlay tag (hosted se-devtools.js; opens with Shift+Alt+S or
+    # `?se=1`). Needs the project id + public client key, both taken from
+    # configure unless passed.
+    def devtools_script_tag(project_id = nil, client_key: nil, base_url: nil, defer: true)
+      require_engine("devtools_script_tag").devtools_script_tag(
+        project_id, client_key: client_key, base_url: base_url, defer: defer
+      )
+    end
+
     # see() structured error reporting — package-level, dispatched through the
     # last-constructed default client (the engine configure built). Never raises
     # into caller code; a call before any client exists warns and no-ops.

data/lib/shipeasy/engine.rb

@@ -472,31 +472,64 @@ module Shipeasy
       # Return the cross-platform SSR bootstrap <script> tag for a request:
       # se-bootstrap.js reads its data-* attributes and hydrates
       # window.__SE_BOOTSTRAP (and writes the anon cookie). No key is embedded.
-      def bootstrap_script_tag(user, anon_id: nil, i18n_profile: "en:prod", base_url: nil)
+      #
+      # Every argument is OPTIONAL and falls back to `Shipeasy.configure`:
+      # `user` to an anonymous request, `i18n_profile:` to `config.profile`,
+      # `base_url:` to `config.cdn_base_url` — so `bootstrap_script_tag` alone
+      # is a valid call for a logged-out page.
+      def bootstrap_script_tag(user = nil, anon_id: nil, i18n_profile: nil, base_url: nil)
+        user ||= {}
         payload = evaluate(user)
-        base = cdn_base(base_url)
+        base = cdn_base(base_url || Shipeasy.config.cdn_base_url)
         attrs = [
           "data-se-bootstrap",
           attr("data-flags", JSON.generate(payload["flags"])),
           attr("data-configs", JSON.generate(payload["configs"])),
           attr("data-experiments", JSON.generate(payload["experiments"])),
           attr("data-killswitches", JSON.generate(payload["killswitches"])),
-          attr("data-i18n-profile", i18n_profile || "en:prod"),
+          attr("data-i18n-profile", resolved_profile(i18n_profile)),
           attr("data-api-url", base),
         ]
         attrs << attr("data-anon-id", anon_id) if anon_id && !anon_id.empty?
         data_user = identity_attrs(user)
         attrs << attr("data-user", data_user) if data_user
-        %(<script src="#{CGI.escapeHTML("#{base}/sdk/bootstrap.js")}" #{attrs.join(' ')}></script>)
+        html %(<script src="#{CGI.escapeHTML("#{base}/sdk/bootstrap.js")}" #{attrs.join(' ')}></script>)
       end
 
       # Return the i18n loader <script> tag (framework-agnostic; the Rails view
       # helper Shipeasy::I18n::ViewHelpers#i18n_script_tag is separate). The
       # loader fetches translations for the profile using the PUBLIC client key.
-      def i18n_script_tag(client_key, profile: "en:prod", base_url: nil)
-        base = cdn_base(base_url)
-        %(<script src="#{CGI.escapeHTML("#{base}/sdk/i18n/loader.js")}" ) +
-          %(#{attr('data-key', client_key)} #{attr('data-profile', profile || 'en:prod')}></script>)
+      #
+      # Every argument is OPTIONAL and falls back to `Shipeasy.configure`:
+      # `client_key` to `config.public_key`, `profile:` to `config.profile`,
+      # `base_url:` to `config.cdn_base_url`.
+      def i18n_script_tag(client_key = nil, profile: nil, base_url: nil)
+        base = cdn_base(base_url || Shipeasy.config.cdn_base_url)
+        key  = client_key || Shipeasy.config.public_key
+        warn_missing("i18n_script_tag", "public_key", key)
+        html %(<script src="#{CGI.escapeHTML("#{base}/sdk/i18n/loader.js")}" ) +
+             %(#{attr('data-key', key)} #{attr('data-profile', resolved_profile(profile))}></script>)
+      end
+
+      # Return the devtools overlay <script> tag. se-devtools.js is a hosted,
+      # self-executing bundle — nothing to install — that reads its project and
+      # public client key off the tag. The overlay opens with Shift+Alt+S or on
+      # any page loaded with `?se=1`.
+      #
+      # Every argument is OPTIONAL and falls back to `Shipeasy.configure`:
+      # `project_id` to `config.project_id`, `client_key:` to
+      # `config.public_key`, `base_url:` to `config.cdn_base_url`. `defer:`
+      # (default true) keeps the overlay off the critical rendering path — the
+      # overlay is a developer tool, never needed for first paint.
+      def devtools_script_tag(project_id = nil, client_key: nil, base_url: nil, defer: true)
+        base = cdn_base(base_url || Shipeasy.config.cdn_base_url)
+        pid  = project_id || Shipeasy.config.project_id
+        key  = client_key || Shipeasy.config.public_key
+        warn_missing("devtools_script_tag", "project_id", pid)
+        warn_missing("devtools_script_tag", "public_key", key)
+        attrs = [attr("data-project-id", pid), attr("data-client-api-key", key)]
+        attrs << "defer" if defer
+        html %(<script src="#{CGI.escapeHTML("#{base}/se-devtools.js")}" #{attrs.join(' ')}></script>)
       end
 
       def track(user_id, event_name, props = {})
@@ -747,6 +780,37 @@ module Shipeasy
         %(#{name}="#{CGI.escapeHTML(value.to_s)}")
       end
 
+      # Mark a tag we built ourselves (every interpolated value is already
+      # HTML-escaped) as safe, so `<%= Shipeasy.i18n_script_tag %>` renders the
+      # markup instead of escaping it — no `.html_safe` at the callsite. Plain
+      # String outside Rails, where nothing defines html_safe.
+      def html(tag)
+        tag.respond_to?(:html_safe) ? tag.html_safe : tag
+      end
+
+      # The i18n profile a tag should carry: an explicit argument wins, then the
+      # configured profile, then the platform default.
+      def resolved_profile(profile)
+        p = profile || Shipeasy.config.profile
+        p.nil? || p.to_s.empty? ? "en:prod" : p
+      end
+
+      # A tag built with no key/id is not an error — it renders, and the browser
+      # bundle reports what it needs — but it is never what the caller wanted.
+      # Logged once per (helper, setting): a tag helper runs on every render, and
+      # one misconfiguration must not fill the log with a line per request.
+      def warn_missing(fn_name, setting, value)
+        return unless value.nil? || value.to_s.empty?
+
+        @warned_missing ||= {}
+        return if @warned_missing["#{fn_name}.#{setting}"]
+
+        @warned_missing["#{fn_name}.#{setting}"] = true
+        Shipeasy::Logging.warn "[shipeasy] #{fn_name}: no #{setting} — set c.#{setting} " \
+                               "in Shipeasy.configure (or pass it explicitly); the tag " \
+                               "will render without it"
+      end
+
       # Serialize the server-identified user's traits for the SSR bootstrap tag's
       # data-user attribute: the request user minus `anonymous_id`, dropping
       # nil values only (empty strings and other present values are kept, to

data/lib/shipeasy/i18n/label_fetcher.rb

@@ -1,26 +1,34 @@
 require "net/http"
 require "uri"
 require "json"
-require "digest"
 
 module Shipeasy
   module I18n
     class LabelFetcher
-      MANIFEST_KEY_PREFIX = "i18n:manifest:"
-      LABEL_KEY_PREFIX    = "i18n:label:"
+      LABEL_KEY_PREFIX = "i18n:strings:"
 
       def initialize(config = Shipeasy.config)
         @config = config
       end
 
-      def fetch(profile: @config.profile, chunk: @config.default_chunk)
-        manifest = fetch_manifest(profile)
-        return nil unless manifest
-
-        file_url = manifest[chunk]
-        return nil unless file_url
-
-        fetch_label_file(file_url)
+      # Fetch a profile's published strings.
+      #
+      # Publishing is PROFILE-WIDE: the whole profile is snapshotted into one
+      # blob and served from a single endpoint, so there is no sub-profile unit
+      # to select. This used to fetch a `manifest.json` and index it by "chunk"
+      # — an endpoint the worker never served, so SSR i18n always came back
+      # empty and pages rendered raw `{{var}}` templates and key fallbacks.
+      # (sdk-ts hit the same bug and moved to this endpoint; see its
+      # `fetchLabelsForSSR`.)
+      #
+      # Returns the `{ "locale" => ..., "strings" => { key => value } }` blob,
+      # or nil when it cannot be fetched.
+      def fetch(profile: @config.profile)
+        cache_key = "#{LABEL_KEY_PREFIX}#{@config.public_key}:#{profile}"
+        cache_fetch(cache_key, @config.label_file_cache_ttl) do
+          url = "#{@config.cdn_base_url}/sdk/i18n/strings?profile=#{URI.encode_www_form_component(profile)}"
+          http_get_json(url, { "X-SDK-Key" => @config.public_key.to_s })
+        end
       rescue => e
         ::Rails.logger.warn("[Shipeasy::I18n] Failed to fetch labels: #{e.message}") if defined?(::Rails)
         nil
@@ -28,21 +36,6 @@ module Shipeasy
 
       private
 
-      def fetch_manifest(profile)
-        cache_key = "#{MANIFEST_KEY_PREFIX}#{@config.public_key}:#{profile}"
-        cache_fetch(cache_key, @config.manifest_cache_ttl) do
-          url = "#{@config.cdn_base_url}/labels/#{@config.public_key}/#{profile}/manifest.json"
-          http_get_json(url)
-        end
-      end
-
-      def fetch_label_file(url)
-        cache_key = "#{LABEL_KEY_PREFIX}#{Digest::MD5.hexdigest(url)}"
-        cache_fetch(cache_key, @config.label_file_cache_ttl) do
-          http_get_json(url)
-        end
-      end
-
       def cache_fetch(key, ttl, &block)
         if defined?(::Rails) && ::Rails.cache
           ::Rails.cache.fetch(key, expires_in: ttl.seconds, &block)
@@ -51,13 +44,13 @@ module Shipeasy
         end
       end
 
-      def http_get_json(url)
+      def http_get_json(url, headers = {})
         uri  = URI.parse(url)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl      = (uri.scheme == "https")
         http.open_timeout = @config.http_timeout
         http.read_timeout = @config.http_timeout
-        res  = http.get(uri.request_uri, { "Accept" => "application/json" })
+        res  = http.get(uri.request_uri, { "Accept" => "application/json" }.merge(headers))
         raise "HTTP #{res.code} fetching #{url}" unless res.is_a?(Net::HTTPSuccess)
         JSON.parse(res.body)
       end

data/lib/shipeasy/i18n/view_helpers.rb

@@ -1,18 +1,17 @@
 module Shipeasy
   module I18n
     module ViewHelpers
-      def i18n_head_tags(profile: nil, chunk: nil)
+      def i18n_head_tags(profile: nil)
         safe_join([
-          i18n_inline_data(profile: profile, chunk: chunk),
+          i18n_inline_data(profile: profile),
           i18n_script_tag,
         ], "\n")
       end
 
-      def i18n_inline_data(profile: nil, chunk: nil)
+      def i18n_inline_data(profile: nil)
         config = Shipeasy.config
         label_file = Shipeasy::I18n::LabelFetcher.new.fetch(
           profile: profile || config.profile,
-          chunk:   chunk   || config.default_chunk,
         )
         return "".html_safe unless label_file
 
@@ -29,10 +28,15 @@ module Shipeasy
           async: true,
         }
         attrs[:"data-hide-until-ready"] = "true" if hide_until_ready
-        tag(:script, attrs)
+        # `content_tag`, NOT `tag` — the latter renders a self-closing
+        # `<script … />`, which HTML has no such thing as: the parser treats
+        # everything up to the next `</script>` as this script's body, silently
+        # swallowing whatever the layout puts after us in the <head> (the
+        # bootstrap tag, most often). An explicit close tag is required.
+        content_tag(:script, "", attrs)
       end
 
-      def i18n_t(key, variables = {}, profile: nil, chunk: nil)
+      def i18n_t(key, variables = {}, profile: nil)
         config = Shipeasy.config
         # render_keys_only (default: env==test): return the key verbatim,
         # skipping value resolution + interpolation so tests assert stable data.
@@ -40,7 +44,6 @@ module Shipeasy
 
         label_file = Shipeasy::I18n::LabelFetcher.new.fetch(
           profile: profile || config.profile,
-          chunk:   chunk   || config.default_chunk,
         )
         return key unless label_file && label_file["strings"]
 

data/lib/shipeasy/sdk/version.rb

@@ -1,5 +1,5 @@
 module Shipeasy
   module SDK
-    VERSION = "3.6.0"
+    VERSION = "3.7.0"
   end
 end

data/lib/shipeasy_admin/api/profiles_api.rb

@@ -91,7 +91,7 @@ module Shipeasy::Admin::Generated
     end
 
     # List i18n profiles
-    # Returns every locale profile in the project (e.g. `en:prod`, `fr:prod`).  **Use case:** Discover which locale profiles exist before pushing keys or publishing a chunk.
+    # Returns every locale profile in the project (e.g. `en:prod`, `fr:prod`).  **Use case:** Discover which locale profiles exist before pushing keys or publishing.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_project_id Project the request operates on. Optional — defaults to the project the SDK key belongs to; pass it only to scope a multi-project key (the generated client sets it once from its configuration, so per-call callers never thread it).
     # @return [Array<ListI18nProfilesResponseInner>]
@@ -101,7 +101,7 @@ module Shipeasy::Admin::Generated
     end
 
     # List i18n profiles
-    # Returns every locale profile in the project (e.g. &#x60;en:prod&#x60;, &#x60;fr:prod&#x60;).  **Use case:** Discover which locale profiles exist before pushing keys or publishing a chunk.
+    # Returns every locale profile in the project (e.g. &#x60;en:prod&#x60;, &#x60;fr:prod&#x60;).  **Use case:** Discover which locale profiles exist before pushing keys or publishing.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_project_id Project the request operates on. Optional — defaults to the project the SDK key belongs to; pass it only to scope a multi-project key (the generated client sets it once from its configuration, so per-call callers never thread it).
     # @return [Array<(Array<ListI18nProfilesResponseInner>, Integer, Hash)>] Array<ListI18nProfilesResponseInner> data, response status code and response headers
@@ -151,32 +151,28 @@ module Shipeasy::Admin::Generated
     end
 
     # Publish a profile live
-    # Publish a profile to the CDN — rebuild its KV snapshot + purge the edge. Publishing is PROFILE-WIDE: the whole profile is snapshotted into one KV blob, so the optional `chunk` in the body is an audit label only (it does not scope what ships).  **Use case:** Ship the latest translations live after pushing/updating keys.
+    # Publish a profile to the CDN — rebuild its KV snapshot + purge the edge. Publishing is PROFILE-WIDE: the whole profile is snapshotted into one KV blob, so the body takes no options.  **Use case:** Ship the latest translations live after pushing/updating keys.
     # @param profile_id [String] The profile id to publish.
-    # @param publish_i18n_profile_request [PublishI18nProfileRequest] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_project_id Project the request operates on. Optional — defaults to the project the SDK key belongs to; pass it only to scope a multi-project key (the generated client sets it once from its configuration, so per-call callers never thread it).
+    # @option opts [Object] :body 
     # @return [PublishI18nProfileResponse]
-    def publish_i18n_profile(profile_id, publish_i18n_profile_request, opts = {})
-      data, _status_code, _headers = publish_i18n_profile_with_http_info(profile_id, publish_i18n_profile_request, opts)
+    def publish_i18n_profile(profile_id, opts = {})
+      data, _status_code, _headers = publish_i18n_profile_with_http_info(profile_id, opts)
       data
     end
 
     # Publish a profile live
-    # Publish a profile to the CDN — rebuild its KV snapshot + purge the edge. Publishing is PROFILE-WIDE: the whole profile is snapshotted into one KV blob, so the optional &#x60;chunk&#x60; in the body is an audit label only (it does not scope what ships).  **Use case:** Ship the latest translations live after pushing/updating keys.
+    # Publish a profile to the CDN — rebuild its KV snapshot + purge the edge. Publishing is PROFILE-WIDE: the whole profile is snapshotted into one KV blob, so the body takes no options.  **Use case:** Ship the latest translations live after pushing/updating keys.
     # @param profile_id [String] The profile id to publish.
-    # @param publish_i18n_profile_request [PublishI18nProfileRequest] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_project_id Project the request operates on. Optional — defaults to the project the SDK key belongs to; pass it only to scope a multi-project key (the generated client sets it once from its configuration, so per-call callers never thread it).
+    # @option opts [Object] :body 
     # @return [Array<(PublishI18nProfileResponse, Integer, Hash)>] PublishI18nProfileResponse data, response status code and response headers
-    def publish_i18n_profile_with_http_info(profile_id, publish_i18n_profile_request, opts = {})
+    def publish_i18n_profile_with_http_info(profile_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: ProfilesApi.publish_i18n_profile ...'
       end
-      # verify the required parameter 'publish_i18n_profile_request' is set
-      if @api_client.config.client_side_validation && publish_i18n_profile_request.nil?
-        fail ArgumentError, "Missing the required parameter 'publish_i18n_profile_request' when calling ProfilesApi.publish_i18n_profile"
-      end
       # resource path
       local_var_path = '/api/admin/i18n/profiles/{profileId}/publish'.sub('{profileId}', CGI.escape(profile_id.to_s))
 
@@ -198,7 +194,7 @@ module Shipeasy::Admin::Generated
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(publish_i18n_profile_request)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(opts[:'body'])
 
       # return_type
       return_type = opts[:debug_return_type] || 'PublishI18nProfileResponse'

data/lib/shipeasy_admin/models/list_i18n_keys_response_keys_inner.rb

@@ -34,9 +34,6 @@ module Shipeasy::Admin::Generated
     # Owning profile id.
     attr_accessor :profile_id
 
-    # Owning chunk (authoring grouping) id.
-    attr_accessor :chunk_id
-
     # ISO-8601 timestamp of the last edit.
     attr_accessor :updated_at
 
@@ -52,7 +49,6 @@ module Shipeasy::Admin::Generated
         :'description' => :'description',
         :'variables' => :'variables',
         :'profile_id' => :'profileId',
-        :'chunk_id' => :'chunkId',
         :'updated_at' => :'updatedAt',
         :'updated_by' => :'updatedBy'
       }
@@ -77,7 +73,6 @@ module Shipeasy::Admin::Generated
         :'description' => :'String',
         :'variables' => :'Array<String>',
         :'profile_id' => :'String',
-        :'chunk_id' => :'String',
         :'updated_at' => :'String',
         :'updated_by' => :'String'
       }
@@ -139,10 +134,6 @@ module Shipeasy::Admin::Generated
         self.profile_id = attributes[:'profile_id']
       end
 
-      if attributes.key?(:'chunk_id')
-        self.chunk_id = attributes[:'chunk_id']
-      end
-
       if attributes.key?(:'updated_at')
         self.updated_at = attributes[:'updated_at']
       end
@@ -223,7 +214,6 @@ module Shipeasy::Admin::Generated
           description == o.description &&
           variables == o.variables &&
           profile_id == o.profile_id &&
-          chunk_id == o.chunk_id &&
           updated_at == o.updated_at &&
           updated_by == o.updated_by
     end
@@ -237,7 +227,7 @@ module Shipeasy::Admin::Generated
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [id, key, value, description, variables, profile_id, chunk_id, updated_at, updated_by].hash
+      [id, key, value, description, variables, profile_id, updated_at, updated_by].hash
     end
 
     # Builds the object from hash

data/lib/shipeasy_admin/models/publish_i18n_profile_response.rb

@@ -22,9 +22,6 @@ module Shipeasy::Admin::Generated
     # Profile that was published.
     attr_accessor :profile_id
 
-    # Audit chunk label, or `null` when none was given.
-    attr_accessor :chunk
-
     # ISO-8601 timestamp of the publish.
     attr_accessor :published_at
 
@@ -73,7 +70,6 @@ module Shipeasy::Admin::Generated
       {
         :'ok' => :'ok',
         :'profile_id' => :'profile_id',
-        :'chunk' => :'chunk',
         :'published_at' => :'published_at',
         :'version' => :'version',
         :'key_count' => :'key_count',
@@ -99,7 +95,6 @@ module Shipeasy::Admin::Generated
       {
         :'ok' => :'Boolean',
         :'profile_id' => :'String',
-        :'chunk' => :'String',
         :'published_at' => :'String',
         :'version' => :'String',
         :'key_count' => :'Float',
@@ -113,7 +108,6 @@ module Shipeasy::Admin::Generated
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
-        :'chunk',
       ])
     end
 
@@ -145,12 +139,6 @@ module Shipeasy::Admin::Generated
         self.profile_id = nil
       end
 
-      if attributes.key?(:'chunk')
-        self.chunk = attributes[:'chunk']
-      else
-        self.chunk = nil
-      end
-
       if attributes.key?(:'published_at')
         self.published_at = attributes[:'published_at']
       else
@@ -338,7 +326,6 @@ module Shipeasy::Admin::Generated
       self.class == o.class &&
           ok == o.ok &&
           profile_id == o.profile_id &&
-          chunk == o.chunk &&
           published_at == o.published_at &&
           version == o.version &&
           key_count == o.key_count &&
@@ -357,7 +344,7 @@ module Shipeasy::Admin::Generated
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [ok, profile_id, chunk, published_at, version, key_count, changed, purged, kv_verified, warning].hash
+      [ok, profile_id, published_at, version, key_count, changed, purged, kv_verified, warning].hash
     end
 
     # Builds the object from hash

data/lib/shipeasy_admin/models/push_i18n_keys_request.rb

@@ -19,9 +19,6 @@ module Shipeasy::Admin::Generated
     # Target profile id to add keys to.
     attr_accessor :profile_id
 
-    # Logical grouping the new keys are filed under. Defaults to `default`.
-    attr_accessor :chunk
-
     # Keys to add. Insert-only — existing keys are reported back as `skipped`.
     attr_accessor :keys
 
@@ -29,7 +26,6 @@ module Shipeasy::Admin::Generated
     def self.attribute_map
       {
         :'profile_id' => :'profile_id',
-        :'chunk' => :'chunk',
         :'keys' => :'keys'
       }
     end
@@ -48,7 +44,6 @@ module Shipeasy::Admin::Generated
     def self.openapi_types
       {
         :'profile_id' => :'String',
-        :'chunk' => :'String',
         :'keys' => :'Array<PushI18nKeysRequestKeysInner>'
       }
     end
@@ -81,10 +76,6 @@ module Shipeasy::Admin::Generated
         self.profile_id = nil
       end
 
-      if attributes.key?(:'chunk')
-        self.chunk = attributes[:'chunk']
-      end
-
       if attributes.key?(:'keys')
         if (value = attributes[:'keys']).is_a?(Array)
           self.keys = value
@@ -145,7 +136,6 @@ module Shipeasy::Admin::Generated
       return true if self.equal?(o)
       self.class == o.class &&
           profile_id == o.profile_id &&
-          chunk == o.chunk &&
           keys == o.keys
     end
 
@@ -158,7 +148,7 @@ module Shipeasy::Admin::Generated
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [profile_id, chunk, keys].hash
+      [profile_id, keys].hash
     end
 
     # Builds the object from hash

data/lib/shipeasy_admin/models/push_i18n_keys_response.rb

@@ -28,17 +28,13 @@ module Shipeasy::Admin::Generated
     # Number of keys skipped (== `skipped.length`).
     attr_accessor :skipped_count
 
-    # The chunk the keys were filed under.
-    attr_accessor :chunk
-
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         :'added' => :'added',
         :'skipped' => :'skipped',
         :'pushed_count' => :'pushed_count',
-        :'skipped_count' => :'skipped_count',
-        :'chunk' => :'chunk'
+        :'skipped_count' => :'skipped_count'
       }
     end
 
@@ -58,8 +54,7 @@ module Shipeasy::Admin::Generated
         :'added' => :'Array<String>',
         :'skipped' => :'Array<String>',
         :'pushed_count' => :'Float',
-        :'skipped_count' => :'Float',
-        :'chunk' => :'String'
+        :'skipped_count' => :'Float'
       }
     end
 
@@ -112,10 +107,6 @@ module Shipeasy::Admin::Generated
       else
         self.skipped_count = nil
       end
-
-      if attributes.key?(:'chunk')
-        self.chunk = attributes[:'chunk']
-      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -201,8 +192,7 @@ module Shipeasy::Admin::Generated
           added == o.added &&
           skipped == o.skipped &&
           pushed_count == o.pushed_count &&
-          skipped_count == o.skipped_count &&
-          chunk == o.chunk
+          skipped_count == o.skipped_count
     end
 
     # @see the `==` method
@@ -214,7 +204,7 @@ module Shipeasy::Admin::Generated
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [added, skipped, pushed_count, skipped_count, chunk].hash
+      [added, skipped, pushed_count, skipped_count].hash
     end
 
     # Builds the object from hash

data/lib/shipeasy_admin.rb

@@ -153,7 +153,6 @@ require 'shipeasy_admin/models/notify_ops_request'
 require 'shipeasy_admin/models/notify_ops_response'
 require 'shipeasy_admin/models/publish_config_draft_request'
 require 'shipeasy_admin/models/publish_config_draft_response'
-require 'shipeasy_admin/models/publish_i18n_profile_request'
 require 'shipeasy_admin/models/publish_i18n_profile_response'
 require 'shipeasy_admin/models/push_i18n_keys_request'
 require 'shipeasy_admin/models/push_i18n_keys_request_keys_inner'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shipeasy-sdk
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.7.0
 platform: ruby
 authors:
 - Shipeasy, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-20 00:00:00.000000000 Z
+date: 2026-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -311,7 +311,6 @@ files:
 - lib/shipeasy_admin/models/notify_ops_response.rb
 - lib/shipeasy_admin/models/publish_config_draft_request.rb
 - lib/shipeasy_admin/models/publish_config_draft_response.rb
-- lib/shipeasy_admin/models/publish_i18n_profile_request.rb
 - lib/shipeasy_admin/models/publish_i18n_profile_response.rb
 - lib/shipeasy_admin/models/push_i18n_keys_request.rb
 - lib/shipeasy_admin/models/push_i18n_keys_request_keys_inner.rb

data/lib/shipeasy_admin/models/publish_i18n_profile_request.rb

@@ -1,149 +0,0 @@
-=begin
-#Shipeasy Admin API
-
-#REST API for managing feature gates, experiments, configs, universes, and killswitches in a Shipeasy project. Authenticate with an admin SDK key (`Authorization: Bearer sdk_admin_…`) and scope every request to a project via the `X-Project-Id` header.  Mint admin keys via `POST /api/admin/keys` with `type: \"admin\"`. Keys expire after 90 days; rotate with the `revoke` action.
-
-The version of the OpenAPI document: 2.0.0
-
-Generated by: https://openapi-generator.tech
-Generator version: 7.23.0
-
-=end
-
-require 'date'
-require 'time'
-
-module Shipeasy::Admin::Generated
-  # Body for `POST /api/admin/i18n/profiles/{profileId}/publish`. The `chunk` is an audit label only.
-  class PublishI18nProfileRequest < ApiModelBase
-    # Optional chunk label to stamp on the audit log. Publishing is profile-wide regardless — the whole profile is snapshotted into one KV blob.
-    attr_accessor :chunk
-
-    # Attribute mapping from ruby-style variable name to JSON key.
-    def self.attribute_map
-      {
-        :'chunk' => :'chunk'
-      }
-    end
-
-    # Returns attribute mapping this model knows about
-    def self.acceptable_attribute_map
-      attribute_map
-    end
-
-    # Returns all the JSON keys this model knows about
-    def self.acceptable_attributes
-      acceptable_attribute_map.values
-    end
-
-    # Attribute type mapping.
-    def self.openapi_types
-      {
-        :'chunk' => :'String'
-      }
-    end
-
-    # List of attributes with nullable: true
-    def self.openapi_nullable
-      Set.new([
-      ])
-    end
-
-    # Initializes the object
-    # @param [Hash] attributes Model attributes in the form of hash
-    def initialize(attributes = {})
-      if (!attributes.is_a?(Hash))
-        fail ArgumentError, "The input argument (attributes) must be a hash in `Shipeasy::Admin::Generated::PublishI18nProfileRequest` initialize method"
-      end
-
-      # check to see if the attribute exists and convert string to symbol for hash key
-      acceptable_attribute_map = self.class.acceptable_attribute_map
-      attributes = attributes.each_with_object({}) { |(k, v), h|
-        if (!acceptable_attribute_map.key?(k.to_sym))
-          fail ArgumentError, "`#{k}` is not a valid attribute in `Shipeasy::Admin::Generated::PublishI18nProfileRequest`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
-        end
-        h[k.to_sym] = v
-      }
-
-      if attributes.key?(:'chunk')
-        self.chunk = attributes[:'chunk']
-      end
-    end
-
-    # Show invalid properties with the reasons. Usually used together with valid?
-    # @return Array for valid properties with the reasons
-    def list_invalid_properties
-      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
-      invalid_properties = Array.new
-      invalid_properties
-    end
-
-    # Check to see if the all the properties in the model are valid
-    # @return true if the model is valid
-    def valid?
-      warn '[DEPRECATED] the `valid?` method is obsolete'
-      true
-    end
-
-    # Checks equality by comparing each attribute.
-    # @param [Object] Object to be compared
-    def ==(o)
-      return true if self.equal?(o)
-      self.class == o.class &&
-          chunk == o.chunk
-    end
-
-    # @see the `==` method
-    # @param [Object] Object to be compared
-    def eql?(o)
-      self == o
-    end
-
-    # Calculates hash code according to all attributes.
-    # @return [Integer] Hash code
-    def hash
-      [chunk].hash
-    end
-
-    # Builds the object from hash
-    # @param [Hash] attributes Model attributes in the form of hash
-    # @return [Object] Returns the model itself
-    def self.build_from_hash(attributes)
-      return nil unless attributes.is_a?(Hash)
-      attributes = attributes.transform_keys(&:to_sym)
-      transformed_hash = {}
-      openapi_types.each_pair do |key, type|
-        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-          transformed_hash["#{key}"] = nil
-        elsif type =~ /\AArray<(.*)>/i
-          # check to ensure the input is an array given that the attribute
-          # is documented as an array but the input is not
-          if attributes[attribute_map[key]].is_a?(Array)
-            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
-          end
-        elsif !attributes[attribute_map[key]].nil?
-          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
-        end
-      end
-      new(transformed_hash)
-    end
-
-    # Returns the object in the form of hash
-    # @return [Hash] Returns the object in the form of hash
-    def to_hash
-      hash = {}
-      self.class.attribute_map.each_pair do |attr, param|
-        value = self.send(attr)
-        if value.nil?
-          is_nullable = self.class.openapi_nullable.include?(attr)
-          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
-        end
-
-        hash[param] = _to_hash(value)
-      end
-      hash
-    end
-
-  end
-
-end