flexiq 2.1.0

data/lib/flexiq/rpc_error.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # The server answered and refused: a `google.rpc.Status` with its `ErrorInfo`.
+  #
+  # Raised when a call fails, and also carried, unraised, by a batch item that did not land.
+  # Branch on `#reason` (see FlexiQ::Reason); `#code` is a category, `#message` is prose.
+  class RPCError < Error
+    ERROR_INFO_TYPE = "type.googleapis.com/google.rpc.ErrorInfo"
+    RETRY_INFO_TYPE = "type.googleapis.com/google.rpc.RetryInfo"
+
+    # For a reply with no FlexiQ body (a proxy's 502, say): the code the HTTP status stands for.
+    CODE_FOR_HTTP_STATUS = {
+      400 => "INVALID_ARGUMENT", 401 => "UNAUTHENTICATED", 403 => "PERMISSION_DENIED",
+      404 => "NOT_FOUND", 409 => "ABORTED", 429 => "RESOURCE_EXHAUSTED", 499 => "CANCELLED",
+      501 => "UNIMPLEMENTED", 503 => "UNAVAILABLE", 504 => "DEADLINE_EXCEEDED"
+    }.freeze
+    private_constant :CODE_FOR_HTTP_STATUS
+
+    # `google.rpc.Code` name, e.g. "RESOURCE_EXHAUSTED".
+    attr_reader :code
+    # HTTP status the JSON door answered with.
+    attr_reader :http_status
+    # ErrorInfo reason, or nil when the server sent none.
+    attr_reader :reason
+    # Per-reason facts; every value a String.
+    attr_reader :metadata
+    # Seconds the server asked the caller to wait (Rational), or nil.
+    attr_reader :retry_after
+
+    # Reads the `{"code", "status", "message", "details"}` object the JSON door renders.
+    def self.from_status(status, http_status: nil)
+      details = Array(status["details"])
+      info = details.find { |d| d.is_a?(Hash) && d["@type"] == ERROR_INFO_TYPE && d["domain"] == Reason::DOMAIN }
+      retry_info = details.find { |d| d.is_a?(Hash) && d["@type"] == RETRY_INFO_TYPE }
+      new(
+        status["message"].to_s,
+        code: status["status"] || "UNKNOWN",
+        http_status: Wire::Int64.load(status["code"]) || http_status,
+        reason: info&.fetch("reason", nil),
+        metadata: string_map(info&.fetch("metadata", nil)),
+        retry_after: retry_info && Wire::Duration.load(retry_info["retryDelay"])
+      )
+    end
+
+    # A refusal that arrived with no FlexiQ error body.
+    def self.from_http(http_status, body)
+      code = CODE_FOR_HTTP_STATUS.fetch(http_status) { http_status >= 500 ? "INTERNAL" : "UNKNOWN" }
+      new("HTTP #{http_status} with no FlexiQ error body: #{body.to_s[0, 200]}", code: code, http_status: http_status)
+    end
+
+    def self.string_map(value)
+      return {} unless value.is_a?(Hash)
+
+      value.each_with_object({}) { |(k, v), out| out[k.to_s] = v.to_s if v.is_a?(String) }.freeze
+    end
+    private_class_method :string_map
+
+    def initialize(message, code:, http_status: nil, reason: nil, metadata: {}, retry_after: nil)
+      @code = code
+      @http_status = http_status
+      @reason = reason
+      @metadata = metadata
+      @retry_after = retry_after
+      super(reason ? "#{reason} (#{code}): #{message}" : "#{code}: #{message}")
+    end
+
+    # Whether the condition clears on its own. Never a licence to resend a write blind:
+    # resend only with `unique_key` set, reusing the same value.
+    def retryable?
+      return Reason::TRANSIENT.include?(reason) if reason
+
+      %w[UNAVAILABLE DEADLINE_EXCEEDED].include?(code)
+    end
+
+    # A metadata value as an Integer; nil when absent or unreadable (a server bug, not a failure).
+    def metadata_integer(key) = Wire::Int64.load(metadata[key])
+
+    # 0-based position of the failing item when a whole EnqueueBatch failed on one item.
+    def batch_index = metadata_integer("index")
+
+    # `{queue:, pending:, cap:}` for a QUEUE_FULL carrying all three, else nil.
+    def queue_full
+      return nil unless reason == Reason::QUEUE_FULL
+
+      queue = metadata["queue"]
+      pending = metadata_integer("pending")
+      cap = metadata_integer("cap")
+      return nil if queue.nil? || pending.nil? || cap.nil?
+
+      { queue: queue, pending: pending, cap: cap }
+    end
+
+    # The cap on concurrent watches a WATCH_LIMIT credential is holding, else nil.
+    def watch_limit = reason == Reason::WATCH_LIMIT ? metadata_integer("cap") : nil
+
+    # The scope a SCOPE_DENIED credential lacked, else nil.
+    def scope = reason == Reason::SCOPE_DENIED ? metadata["scope"] : nil
+
+    # The graph node a `submit_workflow` refusal names (SCOPE_DENIED or
+    # WORKFLOW_CONSTRUCT_UNSUPPORTED), else nil.
+    def node = metadata["node"]
+
+    # `{node:, field:}` for a WORKFLOW_CONSTRUCT_UNSUPPORTED carrying both, else nil. `field` is
+    # "gate", "cache", "fan_out", "fan_in" or "sub_workflow", or one a newer server added.
+    # One node per refusal, even when several set a construct: clear them one call at a time.
+    def workflow_construct
+      return nil unless reason == Reason::WORKFLOW_CONSTRUCT_UNSUPPORTED
+
+      node = metadata["node"]
+      field = metadata["field"]
+      return nil if node.nil? || field.nil?
+
+      { node: node, field: field }
+    end
+  end
+end

data/lib/flexiq/task_error.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FlexiQ
+  # Why a job failed, read from `Job#error`.
+  #
+  # The canonical form is `{"errtype", "message", "traceback"}` JSON. Anything else — a timeout,
+  # an expiry, a worker-death recovery, a legacy error — is plain text by design, and comes back
+  # with `structured` false and the raw text as the message rather than as an exception.
+  TaskError = Data.define(:errtype, :message, :traceback, :structured, :raw) do
+    # The rule turns on `message` alone: a document with a string message is canonical, and a
+    # missing or mistyped sibling falls back to its default rather than losing the message.
+    def self.parse(raw)
+      fields = JSON.parse(raw)
+      message = fields["message"] if fields.is_a?(Hash)
+      return unstructured(raw) unless message.is_a?(String)
+
+      errtype = fields["errtype"]
+      new(
+        errtype: errtype.is_a?(String) ? errtype : "Error",
+        message: message,
+        traceback: frames(fields["traceback"]),
+        structured: true,
+        raw: raw
+      )
+    rescue JSON::ParserError
+      unstructured(raw)
+    end
+
+    # Writes the canonical document. Key order is part of the cross-SDK shape, and a Hash
+    # literal keeps it.
+    def self.encode(errtype, message, traceback = [])
+      JSON.generate({ "errtype" => errtype.to_s, "message" => message.to_s, "traceback" => traceback.map(&:to_s) })
+    end
+
+    def self.unstructured(raw)
+      new(errtype: nil, message: raw, traceback: [], structured: false, raw: raw)
+    end
+
+    def self.frames(value)
+      value.is_a?(Array) ? value.grep(String) : []
+    end
+    private_class_method :unstructured, :frames
+
+    alias_method :structured?, :structured
+
+    def to_s = errtype ? "#{errtype}: #{message}" : message
+  end
+end

data/lib/flexiq/transition_kind.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # `JobTransitionKind` as symbols; an unknown kind stays raw. Finished-ness is
+  # JobTransition#terminal?, never the kind.
+  module TransitionKind
+    BY_WIRE_NAME = {
+      "JOB_TRANSITION_KIND_SNAPSHOT" => :snapshot,
+      "JOB_TRANSITION_KIND_ENQUEUED" => :enqueued,
+      "JOB_TRANSITION_KIND_STARTED" => :started,
+      "JOB_TRANSITION_KIND_COMPLETED" => :completed,
+      "JOB_TRANSITION_KIND_FAILED" => :failed,
+      "JOB_TRANSITION_KIND_RETRYING" => :retrying,
+      "JOB_TRANSITION_KIND_DEAD" => :dead,
+      "JOB_TRANSITION_KIND_CANCELLED" => :cancelled,
+      "JOB_TRANSITION_KIND_SLEEPING" => :sleeping
+    }.freeze
+
+    KNOWN = BY_WIRE_NAME.values.freeze
+
+    module_function
+
+    def load(value) = BY_WIRE_NAME.fetch(value, value)
+
+    def known?(kind) = KNOWN.include?(kind)
+  end
+end

data/lib/flexiq/transport.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module FlexiQ
+  # HTTP/JSON to the server's JSON door: bearer auth, TLS, and failure mapping.
+  #
+  # One keep-alive connection, serialised by a mutex. Never retries: a resent write may land
+  # twice, and only the caller (holding a `unique_key`) can make a resend safe.
+  class Transport
+    # Raised by Net::HTTP for anything short of an HTTP answer.
+    NETWORK_ERRORS = [
+      IOError, SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError, Net::HTTPBadResponse
+    ].freeze
+    private_constant :NETWORK_ERRORS
+
+    EVENT_STREAM = "text/event-stream"
+    private_constant :EVENT_STREAM
+
+    # `tls:` keys: :ca_file, :ca_path, :cert (OpenSSL::X509::Certificate), :key (OpenSSL::PKey).
+    # `watch_read_timeout`: silence before a watch counts as dropped; keep above the 15 s keepalive.
+    def initialize(url, token:, insecure: false, tls: {}, open_timeout: 5, read_timeout: 30,
+                   write_timeout: 30, watch_read_timeout: 60, user_agent: nil)
+      @uri = parse_url(url, insecure)
+      @authorization = "Bearer #{validate_token(token)}".freeze
+      @user_agent = [user_agent, "flexiq-ruby/#{VERSION}"].compact.join(" ").freeze
+      @tls = tls
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      @watch_read_timeout = watch_read_timeout
+      @http = build_http(read_timeout)
+      @lock = Mutex.new
+    end
+
+    # With a `deadline` (Deadline), the read runs on a connection of its own whose timeouts are
+    # capped by it, so the shared connection's settings are never touched.
+    def get(path, query = {}, deadline: nil)
+      request = Net::HTTP::Get.new(full_path(with_query(path, query)))
+      deadline ? perform_within(request, deadline) : perform(request)
+    end
+
+    # Yields an event stream's body in chunks until the server closes it. Own connection, so it
+    # never blocks unary calls. `deadline` (Deadline) caps every read.
+    def stream(path, query = {}, deadline: nil)
+      request = Net::HTTP::Get.new(full_path(with_query(path, query)))
+      authorize(request, EVENT_STREAM)
+      # Compression would buffer events.
+      request["Accept-Encoding"] = "identity"
+      http = build_http(read_timeout_until(deadline))
+      http.open_timeout = deadline.cap(@open_timeout) if deadline
+      # Older net-http resends an idempotent GET after a mid-body error, restarting the stream
+      # under the caller's parser. The watch decides when to reopen.
+      http.max_retries = 0
+      http.start do
+        http.request(request) do |response|
+          expect_event_stream(response)
+          response.read_body do |chunk|
+            http.read_timeout = read_timeout_until(deadline)
+            yield chunk
+          end
+        end
+      end
+    rescue *NETWORK_ERRORS => e
+      raise TransportError, "GET #{request.path}: #{e.class}: #{e.message}"
+    end
+
+    def post(path, body = nil)
+      request = Net::HTTP::Post.new(full_path(path))
+      request["Content-Type"] = "application/json"
+      request.body = body.nil? ? "" : JSON.generate(body)
+      perform(request)
+    end
+
+    def close
+      @lock.synchronize { @http.finish if @http.started? }
+    end
+
+    private
+
+    def parse_url(url, insecure)
+      uri = URI.parse(url.to_s)
+      raise ConfigurationError, "server URL must be http(s)://host[:port], got #{url.inspect}" unless uri.host
+      raise ConfigurationError, "server URL must not carry a query or fragment" if uri.query || uri.fragment
+
+      case uri.scheme
+      when "https" then uri
+      when "http"
+        return uri if insecure
+
+        raise ConfigurationError, "refusing to send a bearer token over plaintext http://; " \
+                                  "use https://, or pass insecure: true for a loopback or socket you trust"
+      else raise ConfigurationError, "unsupported URL scheme #{uri.scheme.inspect}"
+      end
+    rescue URI::InvalidURIError => e
+      raise ConfigurationError, "invalid server URL: #{e.message}"
+    end
+
+    # The token is opaque and never parsed; only a value that cannot form a header is refused.
+    def validate_token(token)
+      raise ConfigurationError, "a token is required" if token.nil? || token.to_s.strip.empty?
+      raise ConfigurationError, "a token cannot contain line breaks" if token.to_s.match?(/[\r\n]/)
+
+      token.to_s
+    end
+
+    def build_http(read_timeout)
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.open_timeout = @open_timeout
+      http.read_timeout = read_timeout
+      http.write_timeout = @write_timeout
+      configure_tls(http, @tls) if @uri.scheme == "https"
+      http
+    end
+
+    def configure_tls(http, tls)
+      unknown = tls.keys - %i[ca_file ca_path cert key]
+      raise ConfigurationError, "unknown tls option(s): #{unknown.join(", ")}" unless unknown.empty?
+
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.verify_hostname = true
+      http.min_version = OpenSSL::SSL::TLS1_2_VERSION
+      http.ca_file = tls[:ca_file] if tls[:ca_file]
+      http.ca_path = tls[:ca_path] if tls[:ca_path]
+      http.cert = tls[:cert] if tls[:cert]
+      http.key = tls[:key] if tls[:key]
+    end
+
+    # A base URL may carry a path prefix, for a server mounted behind a proxy.
+    def full_path(path) = "#{@uri.path.chomp("/")}#{path}"
+
+    def with_query(path, query)
+      query = query.compact
+      query.empty? ? path : "#{path}?#{URI.encode_www_form(query)}"
+    end
+
+    def authorize(request, accept)
+      request["Authorization"] = @authorization
+      request["Accept"] = accept
+      request["User-Agent"] = @user_agent
+    end
+
+    def read_timeout_until(deadline) = deadline ? deadline.cap(@watch_read_timeout) : @watch_read_timeout
+
+    def perform(request)
+      authorize(request, "application/json")
+      response = @lock.synchronize do
+        @http.start unless @http.started?
+        @http.request(request)
+      end
+      interpret(response)
+    rescue *NETWORK_ERRORS => e
+      close_quietly
+      raise TransportError, "#{request.method} #{request.path}: #{e.class}: #{e.message}"
+    end
+
+    def perform_within(request, deadline)
+      authorize(request, "application/json")
+      http = build_http(deadline.cap(@read_timeout))
+      http.open_timeout = deadline.cap(@open_timeout)
+      http.max_retries = 0 # a resend would restart the clock the deadline bounds
+      interpret(http.start { http.request(request) })
+    rescue *NETWORK_ERRORS => e
+      raise TransportError, "#{request.method} #{request.path}: #{e.class}: #{e.message}"
+    end
+
+    def interpret(response)
+      status = response.code.to_i
+      refuse(response, status) unless status.between?(200, 299)
+
+      success_body(parse_json(response.body), status)
+    end
+
+    # A 2xx that is not an event stream came from something else, e.g. a proxy.
+    def expect_event_stream(response)
+      status = response.code.to_i
+      refuse(response, status) unless status.between?(200, 299)
+      return if response.content_type == EVENT_STREAM
+
+      raise TransportError, "HTTP #{status} answered #{response.content_type.inspect}, not #{EVENT_STREAM}"
+    end
+
+    def refuse(response, status)
+      body = parse_json(response.body)
+      error = body.is_a?(Hash) && body["error"].is_a?(Hash) ? body["error"] : nil
+      raise RPCError.from_status(error, http_status: status) if error
+
+      raise RPCError.from_http(status, response.body)
+    end
+
+    def success_body(body, status)
+      raise TransportError, "HTTP #{status} answered with a body that is not a JSON object" unless body.is_a?(Hash)
+
+      body
+    end
+
+    def parse_json(text)
+      return nil if text.nil? || text.empty?
+
+      JSON.parse(text)
+    rescue JSON::ParserError
+      nil
+    end
+
+    # A connection that failed mid-request cannot be reused; the next call reconnects.
+    def close_quietly
+      @lock.synchronize { @http.finish if @http.started? }
+    rescue IOError
+      nil
+    end
+  end
+end

data/lib/flexiq/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # Mirrored from the workspace version by scripts/version.mjs; never hand-edit.
+  VERSION = "2.1.0"
+end

data/lib/flexiq/watch/by_ids.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  class Watch
+    # Id watch. Resumes by reopening on unfinished ids; each gets a fresh snapshot.
+    class ByIds < Watch
+      def initialize(transport, job_ids, deadline: nil)
+        super(transport, deadline: deadline)
+        @pending = Array(job_ids).map(&:to_s).uniq
+        raise ArgumentError, "watch_jobs needs at least one job id" if @pending.empty?
+      end
+
+      private
+
+      def query = { "jobIds" => @pending }
+
+      def finished? = @pending.empty?
+
+      # No cursor on an id watch, so an unknown arm is dropped.
+      def show?(item)
+        case item
+        when JobTransition
+          @pending.delete(item.job_id) if item.terminal?
+          true
+        when JobNotFound
+          @pending.delete(item.job_id)
+          true
+        else false
+        end
+      end
+    end
+  end
+end

data/lib/flexiq/watch/by_queue.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  class Watch
+    # Queue watch. Resumes from the last cursor of any item; an expired one yields a WatchGap
+    # and restarts from now.
+    class ByQueue < Watch
+      def initialize(transport, queue, resume_cursor)
+        super(transport)
+        @queue = queue.to_s
+        @cursor = resume_cursor.nil? || resume_cursor.empty? ? nil : resume_cursor
+      end
+
+      private
+
+      def query = { "queue" => @queue, "resumeCursor" => @cursor }
+
+      def show?(item)
+        @cursor = item.cursor if item.respond_to?(:cursor) && item.cursor
+        true
+      end
+
+      def recover(error, block)
+        return super unless error.reason == Reason::WATCH_CURSOR_EXPIRED && @cursor
+
+        lost = @cursor
+        @cursor = nil
+        hand_over(WatchGap.new(lost_cursor: lost), block)
+        :now
+      end
+    end
+  end
+end

data/lib/flexiq/watch.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "json"
+
+module FlexiQ
+  # Internal: one watch kept alive across streams. Behind Client#watch_jobs / #watch_queue.
+  #
+  # Reopens a stream that drops for a reason that clears. Before the first item, every failure
+  # raises, so a bad URL or a token at its cap fails loudly instead of spinning.
+  class Watch
+    PATH = "/v1/jobs:watch"
+
+    # Contract: reopen on these.
+    REOPEN = [Reason::WATCH_OVERFLOW, Reason::SHUTTING_DOWN].freeze
+
+    # `deadline` (Deadline): raise WaitTimeoutError once it passes.
+    def initialize(transport, deadline: nil)
+      @transport = transport
+      @deadline = deadline
+      @backoff = Backoff.new
+      @opened = false
+      @caller_error = nil
+    end
+
+    # Yields items until finished; breaking out closes the stream.
+    def run(&block)
+      until finished?
+        check_deadline
+        pace = attempt(block)
+        @backoff.pause(@deadline) if pace == :later && !finished?
+      end
+    end
+
+    private
+
+    # The query this watch opens its next stream with.
+    def query = raise NotImplementedError
+
+    def finished? = false
+
+    # Records an item; true when the caller should see it.
+    def show?(_item) = true
+
+    # How soon to reopen after `error`: :now, :later, or nil to raise it.
+    def recover(error, _block)
+      return :later if REOPEN.include?(error.reason)
+
+      @opened && error.retryable? ? :later : nil
+    end
+
+    # One stream, open to close. Returns how soon to open the next.
+    def attempt(block)
+      read(block)
+      :later # closed cleanly before the watch finished: the server ended it early
+    rescue RPCError => e
+      raise @caller_error if @caller_error
+
+      recover(e, block) || raise
+    rescue TransportError
+      # The transport wraps an IOError or SystemCallError the block raised; hand back the original.
+      raise @caller_error if @caller_error
+
+      check_deadline # a read cut short by the deadline is a timeout, not a drop
+      raise unless @opened
+
+      :later
+    end
+
+    def check_deadline
+      raise WaitTimeoutError, "gave up after #{@deadline.seconds}s" if @deadline&.expired?
+    end
+
+    def read(block)
+      parser = Wire::SSE::Parser.new
+      ended = false
+      @transport.stream(PATH, query, deadline: @deadline) do |chunk|
+        check_deadline # keepalives alone would keep a read alive past it
+        parser.feed(chunk) do |event|
+          case event.type
+          when "message" then deliver(item(event.data), block)
+          when "error" then raise failure(event.data)
+          when "end" then ended = true # the server closes next
+          end
+        end
+      end
+      raise TransportError, "the watch closed without an end or error event" unless ended
+    end
+
+    def deliver(item, block)
+      @opened = true
+      @backoff.reset
+      hand_over(item, block) if show?(item)
+    end
+
+    # Tags the block's own errors so they are never mistaken for the stream failing.
+    def hand_over(item, block)
+      block.call(item)
+    rescue StandardError => e
+      @caller_error = e
+      raise
+    end
+
+    # One WatchJobsResponse. An unknown arm reads as a checkpoint, keeping its cursor.
+    def item(data)
+      json = parse_json(data)
+      raise TransportError, "a watch item is not a JSON object: #{data[0, 200]}" unless json.is_a?(Hash)
+
+      cursor = json["cursor"].is_a?(String) && !json["cursor"].empty? ? json["cursor"] : nil
+      if json["transition"].is_a?(Hash)
+        JobTransition.from_json(json["transition"], cursor: cursor)
+      elsif json["notFoundJobId"].is_a?(String)
+        JobNotFound.new(job_id: json["notFoundJobId"])
+      else
+        WatchCheckpoint.new(cursor: cursor)
+      end
+    end
+
+    # An `error` event carries the facade's usual error body.
+    def failure(data)
+      body = parse_json(data)
+      return RPCError.from_status(body["error"]) if body.is_a?(Hash) && body["error"].is_a?(Hash)
+
+      TransportError.new("the watch failed with an unreadable error event: #{data[0, 200]}")
+    end
+
+    def parse_json(data)
+      JSON.parse(data)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/flexiq/watch_items.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # An id this token cannot see (missing or another namespace). Finished.
+  JobNotFound = Data.define(:job_id)
+
+  # A queue-watch position with nothing to report: the opening checkpoint or an unknown arm.
+  # Keep its cursor like any other.
+  WatchCheckpoint = Data.define(:cursor)
+
+  # The resume cursor expired; transitions after `lost_cursor` were missed.
+  WatchGap = Data.define(:lost_cursor)
+end

data/lib/flexiq/wire/bytes.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  module Wire
+    # proto3 JSON `bytes`: base64. Written standard and padded; read in either alphabet,
+    # padding optional, as proto3 JSON allows.
+    module Bytes
+      module_function
+
+      def dump(bytes) = [bytes].pack("m0")
+
+      def load(text)
+        return nil if text.nil?
+
+        standard = text.tr("-_", "+/")
+        standard += "=" * (-standard.length % 4)
+        standard.unpack1("m0")
+      rescue ArgumentError
+        raise CodecError, "a bytes field is not valid base64"
+      end
+    end
+  end
+end