axhub-sdk 0.5.0 → 0.7.0

data/lib/axhub_sdk/data/client.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-require_relative 'dsl/schema'
-require_relative 'dsl/validation'
-require_relative 'errors'
-require_relative 'pagination'
-require_relative 'projection'
-require_relative 'schema_cache'
-require_relative 'where_serializer'
-require_relative 'discover'
-
-module AxHub
-  module Data
-    # Ergonomic data layer: fluent builder + dynamic-table CRUD + offset
-    # pagination (mirrors node index.ts DataClient / TenantDataFactory /
-    # AppDataFactory / DataTableClient).
-    #
-    # Wire paths (EXACTLY as node, via the raw-path transport so row bodies and
-    # the list envelope are returned verbatim, no snake->camel rewriting):
-    #   list / insert         GET|POST          /data/{tenant}/{app}/{table}
-    #   get / update / delete  GET|PATCH|DELETE  /data/{tenant}/{app}/{table}/{id}
-    #   count                 GET               /data/{tenant}/{app}/{table}/_count
-    module_function
-
-    def _encode(value)
-      URI.encode_www_form_component(value.to_s)
-    end
-
-    def _clamp_per_page(value)
-      return nil if value.nil?
-      return 100 unless value.is_a?(Numeric) && value.finite?
-
-      [100, [1, value.to_i].max].min
-    end
-
-    def _reject_legacy_page_options(after, before, direction, _table_name)
-      return if after.nil? && before.nil? && direction.nil?
-
-      raise LegacyCursorError.new(
-        'after/before keyset cursors are not supported by the live AX Hub data API; use cursor/page numeric offset pagination'
-      )
-    end
-
-    def _validate_plain_cursor(cursor, _table_name)
-      if cursor.length > MAX_CURSOR_TOKEN_LENGTH
-        raise InvalidCursorError.new("Cursor token exceeds maximum size (#{MAX_CURSOR_TOKEN_LENGTH} chars)")
-      end
-      if cursor.start_with?('v1:')
-        raise LegacyCursorError.new(
-          'Legacy v1: cursor token is not compatible with AX Hub offset-only pagination; restart pagination without cursor'
-        )
-      end
-      if Data.is_v2_cursor(cursor)
-        raise LegacyCursorError.new(
-          'v2 keyset cursors are not supported by the live AX Hub data API; restart pagination and use the numeric cursor returned by list()'
-        )
-      end
-      unless cursor.match?(/\A-?\d+\z/)
-        raise InvalidCursorError.new('Plain cursor must be a positive integer page or a v2: keyset token')
-      end
-      parsed = cursor.to_i
-      raise InvalidCursorError.new('Plain cursor must be a positive integer page or a v2: keyset token') if parsed < 1
-    end
-
-    def _resolve_offset_page(cursor, page, table_name)
-      unless cursor.nil?
-        _validate_plain_cursor(cursor, table_name)
-        return cursor.to_i
-      end
-      return 1 if page.nil?
-      raise InvalidCursorError.new('page must be a positive integer') unless page.is_a?(Integer) && page >= 1
-
-      page
-    end
-  end
-
-  module Data
-    # Client bound to one {tenant}/{app}/{table} with CRUD + pagination.
-    class DataTableClient
-      attr_reader :schema
-
-      def initialize(client, tenant_slug, app_slug, table_name, schema = nil)
-        @client = client
-        @tenant_slug = tenant_slug
-        @app_slug = app_slug
-        @table_name = table_name
-        @schema = schema
-      end
-
-      def list(where: nil, order_by: nil, select: nil, page: nil, page_size: nil, limit: nil, cursor: nil, after: nil, before: nil, direction: nil)
-        Data.validate_select_columns(@schema, select)
-        Data._reject_legacy_page_options(after, before, direction, @table_name)
-        resolved_page = Data._resolve_offset_page(cursor, page, @table_name)
-        per_page = Data._clamp_per_page(page_size.nil? ? limit : page_size)
-        query = Data.serialize_where(where).dup
-        query['per_page'] = per_page unless per_page.nil?
-        query['page'] = resolved_page if resolved_page != 1
-        sort = Data.serialize_order_by(order_by)
-        query['sort'] = sort if sort && sort != ''
-        serialized_select = Data.serialize_select(select)
-        query['_select'] = serialized_select unless serialized_select.nil?
-        raw = Data.map_where_required('list') { @client.request_raw('GET', _path, query: query) } || {}
-        items = Data.project_rows(raw['items'] || [], select)
-        # mirrors node: current_page falls back to the requested page, has_next
-        # reads the backend `has_more` flag verbatim, has_prev derives client-side.
-        current_page = raw['page'].nil? ? resolved_page : raw['page']
-        has_next = !!(raw['has_more'] || false)
-        has_prev = current_page > 1
-        PaginatedList.new(
-          items: items,
-          next_cursor: has_next ? (current_page + 1).to_s : nil,
-          first_cursor: has_prev ? (current_page - 1).to_s : nil,
-          has_next: has_next,
-          has_prev: has_prev,
-          total_is_exact: false
-        )
-      end
-
-      def list_all(where: nil, order_by: nil, select: nil, page_size: nil, limit: nil, &block)
-        base = { where: where, order_by: order_by, select: select, limit: limit }
-        fetcher = lambda do |p|
-          kwargs = base.reject { |_k, v| v.nil? }
-          kwargs[:cursor] = p[:cursor] unless p[:cursor].nil?
-          ps = p[:page_size].nil? ? page_size : p[:page_size]
-          kwargs[:page_size] = ps unless ps.nil?
-          list(**kwargs)
-        end
-        Data.list_all(fetcher, { page_size: page_size }, &block)
-      end
-
-      def count(where: nil)
-        raw = Data.map_where_required('count') { @client.request_raw('GET', "#{_path}/_count", query: Data.serialize_where(where)) } || {}
-        raw['count']
-      end
-
-      def get(row_id, select: nil)
-        Data.validate_select_columns(@schema, select)
-        serialized_select = Data.serialize_select(select)
-        query = serialized_select.nil? ? {} : { '_select' => serialized_select }
-        row = @client.request_raw('GET', _path(row_id), query: query) || {}
-        Data.project_row(row, select)
-      end
-
-      def insert(row)
-        Data.run_schema_validation(@schema, row, 'insert')
-        @client.request_raw('POST', _path, body: row)
-      end
-
-      def insert_many(rows)
-        rows.each { |row| Data.run_schema_validation(@schema, row, 'insert') }
-        # mirrors node: no bulk endpoint exists, so insertMany loops single
-        # inserts and returns { items, count }.
-        items = rows.map { |row| insert(row) }
-        { 'items' => items, 'count' => items.length }
-      end
-
-      def update(row_id, patch)
-        Data.run_schema_validation(@schema, patch, 'update')
-        @client.request_raw('PATCH', _path(row_id), body: patch)
-      end
-
-      def delete(row_id)
-        @client.request_raw('DELETE', _path(row_id))
-        nil
-      end
-
-      private
-
-      def _path(row_id = nil)
-        base = "/data/#{Data._encode(@tenant_slug)}/#{Data._encode(@app_slug)}/#{Data._encode(@table_name)}"
-        row_id.nil? ? base : "#{base}/#{Data._encode(row_id)}"
-      end
-    end
-
-    class AppDataFactory
-      def initialize(data, tenant_slug, app_slug)
-        @data = data
-        @tenant_slug = tenant_slug
-        @app_slug = app_slug
-      end
-
-      def table(table)
-        @data.table(@tenant_slug, @app_slug, table)
-      end
-
-      def discover(table, fresh: nil, ttl_ms: nil)
-        @data.discover(@tenant_slug, @app_slug, table, fresh: fresh, ttl_ms: ttl_ms)
-      end
-
-      def invalidate_schema(table = nil)
-        if table.nil?
-          @data.invalidate_schema
-        else
-          @data.invalidate_schema(@tenant_slug, @app_slug, table)
-        end
-      end
-    end
-
-    class TenantDataFactory
-      def initialize(data, tenant_slug)
-        @data = data
-        @tenant_slug = tenant_slug
-      end
-
-      def app(app_slug)
-        AppDataFactory.new(@data, @tenant_slug, app_slug)
-      end
-    end
-
-    # Entry point for the ergonomic data layer; holds the per-client schema cache
-    # used by discover() (mirrors node DataClient).
-    class DataClient
-      def initialize(client, schema_cache: nil)
-        @client = client
-        @schema_cache = case schema_cache
-                        when SchemaCache then schema_cache
-                        when Hash then SchemaCache.new(**schema_cache.transform_keys(&:to_sym))
-                        else SchemaCache.new
-                        end
-      end
-
-      def table(tenant_slug, app_slug, table)
-        schema = table.is_a?(DataTableSchema) ? table : nil
-        table_name = table.is_a?(DataTableSchema) ? table.table : table
-        DataTableClient.new(@client, tenant_slug, app_slug, table_name, schema)
-      end
-
-      def scoped(tenant_slug)
-        TenantDataFactory.new(self, tenant_slug)
-      end
-
-      def discover(tenant_slug, app_slug, table, fresh: nil, ttl_ms: nil)
-        key = Data.schema_cache_key(tenant_slug, app_slug, table)
-        schema = @schema_cache.get_or_set(key, fresh: fresh, ttl_ms: ttl_ms) do
-          Data.fetch_discovered_schema(@client, tenant_slug, app_slug, table, fresh: fresh, ttl_ms: ttl_ms)
-        end
-        DataTableClient.new(@client, tenant_slug, app_slug, schema.table, schema)
-      end
-
-      def invalidate_schema(tenant_slug = nil, app_slug = nil, table = nil)
-        if !tenant_slug.nil? && !app_slug.nil? && !table.nil?
-          @schema_cache.invalidate(Data.schema_cache_key(tenant_slug, app_slug, table))
-          return
-        end
-        @schema_cache.invalidate
-      end
-    end
-  end
-end

data/lib/axhub_sdk/data/discover.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-require_relative 'dsl/schema'
-require_relative 'errors'
-
-module AxHub
-  module Data
-    # Runtime schema introspection, with appId-resolution PRIMARY and the slug
-    # /inspect endpoint as a best-effort fallback, plus error normalization
-    # (mirrors node/python discover).
-    #
-    # Primary:  GET /api/v1/apps?tenant_slug=... -> GET /api/v1/apps/{appId}/tables/{table}
-    # Fallback: GET /api/v1/tenants/{t}/apps/{a}/tables/{table}/inspect
-    # Neither endpoint has a generated operation-id, so discover goes through the
-    # raw-path transport. camelize: true here so table_name/tableName both resolve
-    # (inspect payload is metadata, not user row data).
-    APP_LOOKUP_PAGE_SIZE = 100
-    APP_LOOKUP_MAX_PAGES = 10
-    APP_LOOKUP_BUDGET_MS = 5_000
-
-    FORBIDDEN_COLUMN_NAMES = %w[__proto__ constructor prototype].freeze
-    COLUMN_NAME_RE = /\A[A-Za-z_][A-Za-z0-9_]*\z/
-
-    module_function
-
-    def _encode(value)
-      URI.encode_www_form_component(value.to_s)
-    end
-
-    def fetch_discovered_schema(client, tenant_slug, app_slug, table, fresh: nil, ttl_ms: nil)
-      # The appId path is the route the `axhub` CLI uses and is verified to work
-      # with a data-ring PAT (2026-06). The slug `/inspect` route rejects a slug
-      # in the {tenant} path segment on the live backend ("tenant_id 형식이 잘못됐어요",
-      # HTTP 400) — a 400 not a 404, so the old slug-first order never reached the
-      # working path. appId is primary; slug inspect is a best-effort fallback. The
-      # appId error is the meaningful one, so it is what surfaces.
-      begin
-        _fetch_app_id_inspect(client, tenant_slug, app_slug, table)
-      rescue StandardError => err
-        begin
-          _fetch_slug_inspect(client, tenant_slug, app_slug, table)
-        rescue StandardError
-          raise _normalize_discover_error(err, table)
-        end
-      end
-    end
-
-    def _fetch_slug_inspect(client, tenant_slug, app_slug, table)
-      path = "/api/v1/tenants/#{_encode(tenant_slug)}/apps/#{_encode(app_slug)}/tables/#{_encode(table)}/inspect"
-      raw = client.request_raw('GET', path, camelize: true)
-      schema_from_inspect_result(table, raw)
-    end
-
-    def _fetch_app_id_inspect(client, tenant_slug, app_slug, table)
-      app_id = _resolve_app_id(client, tenant_slug, app_slug)
-      raise TableNotFoundError.new("Dynamic data table '#{table}' was not found") if app_id.nil? || app_id.empty?
-
-      path = "/api/v1/apps/#{_encode(app_id)}/tables/#{_encode(table)}"
-      raw = client.request_raw('GET', path, camelize: true)
-      schema_from_inspect_result(table, raw)
-    end
-
-    def _resolve_app_id(client, tenant_slug, app_slug)
-      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0
-      cursor = nil
-      APP_LOOKUP_MAX_PAGES.times do |page|
-        if Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0 - started_at > APP_LOOKUP_BUDGET_MS
-          raise IntrospectFailedError.new(
-            "app lookup budget exceeded (#{APP_LOOKUP_BUDGET_MS}ms) while searching for slug '#{app_slug}' in tenant '#{tenant_slug}'"
-          )
-        end
-        query = { 'tenant_slug' => tenant_slug, 'limit' => APP_LOOKUP_PAGE_SIZE }
-        query['cursor'] = cursor if cursor
-        raw = client.request_raw('GET', '/api/v1/apps', query: query, camelize: true)
-        raw ||= {}
-        items = raw['items'] || []
-        match = items.find { |app| app['slug'] == app_slug && app['id'].is_a?(String) }
-        return match['id'] if match && match['id']
-
-        # Empty page on the first request means the tenant truly has no apps.
-        return nil if page.zero? && items.empty?
-
-        next_cursor = raw['next_cursor'] || raw['nextCursor']
-        return nil if next_cursor.nil? || next_cursor == ''
-
-        cursor = next_cursor
-      end
-      raise ScanLimitExceededError.new(
-        "App lookup exceeded #{APP_LOOKUP_MAX_PAGES} pages x #{APP_LOOKUP_PAGE_SIZE} apps without finding slug '#{app_slug}'"
-      )
-    end
-
-    def _normalize_discover_error(err, table)
-      return err if err.is_a?(TableNotFoundError) || err.is_a?(IntrospectFailedError) || err.is_a?(ScanLimitExceededError)
-
-      if _not_found?(err)
-        return TableNotFoundError.new(
-          "Dynamic data table '#{table}' was not found",
-          request_id: (err.respond_to?(:request_id) ? err.request_id : nil)
-        )
-      end
-      status = err.respond_to?(:status) ? err.status : nil
-      if status.is_a?(Integer) && status >= 500
-        return IntrospectFailedError.new(
-          "Failed to introspect dynamic data table '#{table}'",
-          status: status,
-          retryable: (err.respond_to?(:retryable) ? !!err.retryable : false),
-          request_id: (err.respond_to?(:request_id) ? err.request_id : nil)
-        )
-      end
-      err
-    end
-
-    def schema_from_inspect_result(table, raw)
-      raw ||= {}
-      columns = raw['columns'] || []
-      shape = {}
-      columns.each do |column|
-        name = column['name']
-        next if FORBIDDEN_COLUMN_NAMES.include?(name)
-        next unless name.is_a?(String) && COLUMN_NAME_RE.match?(name)
-
-        shape[name] = _column_type_to_def(column['type'])
-      end
-      table_name = raw['tableName'] || raw['table_name'] || raw['name'] || table
-      Data.define_schema({ 'table' => table_name, 'columns' => shape })
-    end
-
-    def _column_type_to_def(col_type)
-      case col_type
-      when 'uuid' then 'uuid'
-      when 'int', 'integer', 'bigint' then 'integer'
-      when 'float', 'numeric', 'double precision', 'real' then 'number'
-      when 'bool', 'boolean' then 'boolean'
-      when 'timestamp', 'timestamptz', 'timestamp with time zone' then 'timestamp'
-      when 'json', 'jsonb' then 'json'
-      else 'string' # text / varchar / character varying / unknown -> string
-      end
-    end
-
-    def _not_found?(err)
-      return true if err.is_a?(TableNotFoundError)
-
-      err.is_a?(AxHub::Error) && err.respond_to?(:status) && err.status == 404
-    end
-  end
-end

data/lib/axhub_sdk/data/dsl/ops.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'schema'
-require_relative '../errors'
-
-module AxHub
-  module Data
-    # Predicate DSL: where(col).eq(v), and_(...), or_/not_/raw plus LIKE escaping
-    # and ReDoS guards (mirrors node/python dsl/ops).
-    #
-    # Query expressions are plain symbol-keyed Hashes:
-    #   { op: :eq|:ne|:gt|:gte|:lt|:lte|:like, column: "c", value: v }
-    #   { op: :in, column: "c", values: [...] }
-    #   { op: :and|:or, clauses: [...] }
-    #   { op: :not, clause: expr }
-    #   { op: :raw, sql: "...", params?: [...] }
-    # Only and(eq/ne/gt/gte/lt/lte/in/like) and bare atoms are pushable to the
-    # live backend; or/not/raw raise in the where-serializer (mirrors node).
-    MAX_LIKE_PATTERN_LENGTH = 1024
-    MAX_CONSECUTIVE_WILDCARDS = 4
-    MAX_LIKE_ALTERNATION_SEGMENTS = 6
-
-    ESCAPE_LIKE_RE = /[\\%_]/
-
-    module_function
-
-    def escape_like(value)
-      return value if value == ''
-
-      value.gsub(ESCAPE_LIKE_RE) { |m| "\\#{m}" }
-    end
-
-    # Reject LIKE patterns that translate to catastrophic-backtracking regex
-    # shapes (mirrors node assertSafeLikePattern).
-    def assert_safe_like_pattern(pattern)
-      if pattern.length > MAX_LIKE_PATTERN_LENGTH
-        raise ValidationError.new("LIKE pattern exceeds #{MAX_LIKE_PATTERN_LENGTH} chars; refuse to compile", 'like_pattern_too_long')
-      end
-
-      run_of_wildcards = 0
-      segments = 0
-      i = 0
-      n = pattern.length
-      while i < n
-        ch = pattern[i]
-        if ch == '\\'
-          i += 2
-          run_of_wildcards = 0
-          next
-        end
-        if ch == '%'
-          run_of_wildcards += 1
-          if run_of_wildcards >= MAX_CONSECUTIVE_WILDCARDS
-            raise ValidationError.new("LIKE pattern has #{run_of_wildcards} consecutive '%'; refuse to compile (ReDoS guard)", 'like_pattern_redos')
-          end
-        else
-          segments += 1 if run_of_wildcards == 1
-          run_of_wildcards = 0
-        end
-        i += 1
-      end
-      if segments > MAX_LIKE_ALTERNATION_SEGMENTS
-        raise ValidationError.new("LIKE pattern has #{segments} '%X%' alternation segments; refuse to compile (ReDoS guard)", 'like_pattern_redos')
-      end
-    end
-
-    def raw(sql, params = nil)
-      params.nil? ? { op: :raw, sql: sql } : { op: :raw, sql: sql, params: params }
-    end
-
-    def and_(*clauses)
-      { op: :and, clauses: clauses }
-    end
-
-    def or_(*clauses)
-      { op: :or, clauses: clauses }
-    end
-
-    def not_(clause)
-      { op: :not, clause: clause }
-    end
-
-    # Start a predicate for a column. Accepts a DataColumn, a String, or a Symbol.
-    #
-    #   where(:status).eq("paid")
-    #   where("status").eq("paid")
-    #   where(schema.cols["status"]).eq("paid")
-    #
-    # Block form (idiomatic Ruby): yields the builder and returns its result, so
-    # the bare-atom expr can be written without a trailing chain.
-    #
-    #   where(:status) { |c| c.eq("paid") }
-    def where(column)
-      name = column.is_a?(DataColumn) ? column.name : column.to_s
-      builder = WhereBuilder.new(name)
-      return yield(builder) if block_given?
-
-      builder
-    end
-
-    class LikeBuilder
-      def initialize(name)
-        @name = name
-      end
-
-      def contains(value)
-        { op: :like, column: @name, value: "%#{Data.escape_like(value)}%" }
-      end
-
-      def starts_with(value)
-        { op: :like, column: @name, value: "#{Data.escape_like(value)}%" }
-      end
-
-      def ends_with(value)
-        { op: :like, column: @name, value: "%#{Data.escape_like(value)}" }
-      end
-
-      def raw(value)
-        Data.assert_safe_like_pattern(value)
-        { op: :like, column: @name, value: value }
-      end
-    end
-
-    class WhereBuilder
-      attr_reader :like
-
-      def initialize(name)
-        @name = name
-        @like = LikeBuilder.new(name)
-      end
-
-      def eq(value)  = _binary(:eq, value)
-      def ne(value)  = _binary(:ne, value)
-      def gt(value)  = _binary(:gt, value)
-      def gte(value) = _binary(:gte, value)
-      def lt(value)  = _binary(:lt, value)
-      def lte(value) = _binary(:lte, value)
-
-      def in_(values)
-        { op: :in, column: @name, values: values.to_a }
-      end
-
-      private
-
-      def _binary(op, value)
-        { op: op, column: @name, value: value }
-      end
-    end
-  end
-end

data/lib/axhub_sdk/data/dsl/schema.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module AxHub
-  module Data
-    # Schema definitions and define_schema (mirrors node/python dsl/schema).
-    #
-    # Column defs are either a primitive type string ("uuid" | "string" |
-    # "number" | "integer" | "boolean" | "timestamp" | "json") or an enum
-    # descriptor { type: "enum", values: [...] }. define_schema builds the `cols`
-    # accessor map used by the where(schema.cols["x"]) typed DSL path.
-    DataColumn = Struct.new(:table, :name, :definition) do
-      def initialize(table:, name:, definition:)
-        super(table, name, definition)
-      end
-    end
-
-    class DataTableSchema
-      attr_reader :table, :columns, :cols, :validate
-
-      def initialize(table:, columns:, cols:, validate: nil)
-        @table = table
-        @columns = columns
-        @cols = cols
-        @validate = validate
-        freeze
-      end
-    end
-
-    module_function
-
-    # Define a data table schema. Two call shapes mirror node's two overloads:
-    #   define_schema("orders", { "id" => "uuid", "total" => "number" })
-    #   define_schema({ "table" => "orders", "columns" => {...} }, validate: ...)
-    # An existing DataTableSchema is re-wrapped, optionally attaching `validate`.
-    def define_schema(table_or_input, columns = nil, validate: nil)
-      if table_or_input.is_a?(DataTableSchema)
-        return DataTableSchema.new(
-          table: table_or_input.table,
-          columns: table_or_input.columns,
-          cols: table_or_input.cols,
-          validate: validate.nil? ? table_or_input.validate : validate
-        )
-      end
-
-      if table_or_input.is_a?(Hash)
-        h = _stringify_keys(table_or_input)
-        table = h['table']
-        shape = _stringify_keys(h['columns'])
-      else
-        table = table_or_input
-        raise ArgumentError, 'define_schema requires columns when called with a table name' if columns.nil?
-
-        shape = _stringify_keys(columns)
-      end
-
-      cols = shape.each_with_object({}) do |(name, definition), acc|
-        acc[name] = DataColumn.new(table: table, name: name, definition: definition)
-      end
-      DataTableSchema.new(table: table, columns: shape, cols: cols, validate: validate)
-    end
-
-    def _stringify_keys(hash)
-      hash.each_with_object({}) { |(k, v), acc| acc[k.to_s] = v }
-    end
-  end
-end

data/lib/axhub_sdk/data/dsl/validation.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'schema'
-require_relative '../errors'
-
-module AxHub
-  module Data
-    # Optional schema validation hook (mirrors node dsl/zod + python validation).
-    #
-    # The SDK duck-types a zod/dry-validation-style validator so the validation
-    # library stays an optional dependency and is never required. A validator is
-    # "schema-like" if it responds to `safe_parse` (or `safeParse`). On `update`
-    # a `partial` variant is used when available.
-    module_function
-
-    def validator_like?(value)
-      !value.nil? && (value.respond_to?(:safe_parse) || value.respond_to?(:safeParse))
-    end
-
-    def _safe_parse(validator, data)
-      validator.respond_to?(:safe_parse) ? validator.safe_parse(data) : validator.safeParse(data)
-    end
-
-    # Validate `data` against schema.validate before any network request. `mode`
-    # is "insert" or "update" (update uses `partial` when available).
-    def run_schema_validation(schema, data, mode)
-      validator = schema&.validate
-      return if validator.nil?
-
-      unless validator_like?(validator)
-        raise AxHub::Error.new(
-          category: 'configuration', code: 'validator_missing',
-          message: 'define_schema validate option requires a schema-like object with safe_parse'
-        )
-      end
-
-      effective = validator
-      effective = validator.partial if mode == 'update' && validator.respond_to?(:partial)
-      result = _safe_parse(effective, data)
-
-      success = _read(result, :success)
-      return if success
-
-      error = _read(result, :error)
-      issues = _read(error, :issues) || []
-      count = issues.empty? ? 1 : issues.length
-      raise ValidationError.new("#{count} validation failure#{count == 1 ? '' : 's'} before network request", 'validation_failed')
-    end
-
-    # Read an attribute from either a duck-typed object or a Hash.
-    def _read(obj, key)
-      return nil if obj.nil?
-      return obj.public_send(key) if obj.respond_to?(key)
-      return obj[key] if obj.is_a?(Hash) && obj.key?(key)
-      return obj[key.to_s] if obj.is_a?(Hash) && obj.key?(key.to_s)
-
-      nil
-    end
-  end
-end