altertable-lakehouse 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aa80cb382f3d5785418303b107e30f5e9fbd4a25f5d9e93c96f952a7fc1eb93
-  data.tar.gz: b774968941cd9af5ce99a24053d6c4f991e0357e90a45c655a7b4717fe9fcf78
+  metadata.gz: 18b992ed254a6445172a0b19f560afbb7380da7109a0c15fcc24dd8cccdca195
+  data.tar.gz: 25ebe5ea1a4e570ad391af48df2bc5a43d87dd46570f702888aefd12be8f9597
 SHA512:
-  metadata.gz: 734bd3df2c06e8c8667ff1a82fef0e4a69ec6ae947f42b29a45bc82c935d3ffcbeea23cd2f491d887da65e347d378b6983ee897ff2cb2433c2efa134d54e15e3
-  data.tar.gz: 12e9c4abf22319aeda9201c6e96e481ce8fc736b3021c2f9204dec50d1d93d6c3c6fdfa9ef32597d3a78e0aa4fcab2a541117b8a820de8c37c1f122d5c52f30b
+  metadata.gz: b08a506dcf3292f1f85400149fb40ea4c9a59183c51157c752039467415bc8fa982c8a298fbef1e7cc7f12e12b1a8a2cbde9736633531495004c8a9b3999a20b
+  data.tar.gz: bd4fcde8127c172009aee8d146eed5601156dc8a9d3206ee9c38c317afa9597d68c113183b6f9fdb44296ab0d4202bb99b690cf30bb9c76bb91f9fde498dfe48

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "0.4.2"
+    ".": "0.5.0"
 }

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.5.0](https://github.com/altertable-ai/altertable-lakehouse-ruby/compare/altertable-lakehouse/v0.4.2...altertable-lakehouse/v0.5.0) (2026-05-28)
+
+
+### Features
+
+* add optional headers to all methods ([#37](https://github.com/altertable-ai/altertable-lakehouse-ruby/issues/37)) ([34e3c2d](https://github.com/altertable-ai/altertable-lakehouse-ruby/commit/34e3c2d943742a5f2a3f6a309154a8ee9aa84dc7))
+
 ## [0.4.2](https://github.com/altertable-ai/altertable-lakehouse-ruby/compare/altertable-lakehouse/v0.4.1...altertable-lakehouse/v0.4.2) (2026-05-27)
 
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    altertable-lakehouse (0.4.2)
+    altertable-lakehouse (0.5.0)
       base64
 
 GEM
@@ -96,6 +96,7 @@ GEM
       sorbet-static (= 0.6.12997)
     sorbet-runtime (0.6.12997)
     sorbet-static (0.6.12997-universal-darwin)
+    sorbet-static (0.6.12997-x86_64-linux)
     sorbet-static-and-runtime (0.6.12997)
       sorbet (= 0.6.12997)
       sorbet-runtime (= 0.6.12997)

data/lib/altertable/lakehouse/client.rb

@@ -11,7 +11,7 @@ module Altertable
       DEFAULT_BASE_URL = "https://api.altertable.ai"
       DEFAULT_TIMEOUT = 10
 
-      def initialize(username: nil, password: nil, basic_auth_token: nil, base_url: nil, timeout: nil, user_agent: nil, adapter: nil)
+      def initialize(username: nil, password: nil, basic_auth_token: nil, base_url: nil, timeout: nil, user_agent: nil, adapter: nil, headers: {})
         # 1. Try passed basic_auth_token
         # 2. Try passed username/password
         # 3. Try ENV["ALTERTABLE_BASIC_AUTH_TOKEN"]
@@ -33,39 +33,39 @@ module Altertable
         @timeout = timeout || DEFAULT_TIMEOUT
         @user_agent = user_agent ? "AltertableRuby/#{VERSION} #{user_agent}" : "AltertableRuby/#{VERSION}"
         
-        headers = {
+        default_headers = {
           "Authorization" => @auth_header,
           "User-Agent" => @user_agent,
           "Content-Type" => "application/json"
         }
 
-        @adapter = select_adapter(adapter, base_url: @base_url, timeout: @timeout, headers: headers)
+        @adapter = select_adapter(adapter, base_url: @base_url, timeout: @timeout, headers: default_headers.merge(headers))
       end
 
       # POST /append
-      def append(catalog:, schema:, table:, payload:, sync: nil)
+      def append(catalog:, schema:, table:, payload:, sync: nil, headers: {})
         params = { catalog: catalog, schema: schema, table: table }
         params[:sync] = sync unless sync.nil?
         req = Models::AppendRequest.new(payload)
-        resp = request(:post, "/append", body: req.to_h, query: params)
+        resp = request(:post, "/append", body: req.to_h, query: params, headers: headers)
         Models::AppendResponse.from_h(resp)
       end
 
       # GET /tasks/:task_id
-      def get_task(task_id)
-        resp = request(:get, "/tasks/#{task_id}")
+      def get_task(task_id, headers: {})
+        resp = request(:get, "/tasks/#{task_id}", headers: headers)
         Models::TaskResponse.from_h(resp)
       end
 
       # POST /query (streamed)
-      def query(statement:, **options)
+      def query(statement:, headers: {}, **options)
         req_body = Models::QueryRequest.new(statement: statement, **options).to_h.to_json
 
         enum = Enumerator.new do |yielder|
           buffer = ""
           
           # Use adapter's stream capability
-          resp = @adapter.post("/query", body: req_body) do |chunk, _|
+          resp = @adapter.post("/query", body: req_body, headers: headers) do |chunk, _|
             buffer << chunk
           end
 
@@ -76,8 +76,8 @@ module Altertable
       end
 
       # POST /query (accumulated)
-      def query_all(statement:, **options)
-        result = query(statement: statement, **options)
+      def query_all(statement:, headers: {}, **options)
+        result = query(statement: statement, headers: headers, **options)
         rows = result.to_a # Accumulate
         {
           metadata: result.metadata,
@@ -87,7 +87,7 @@ module Altertable
       end
 
       # POST /upload
-      def upload(catalog:, schema:, table:, format:, mode:, file_io:, primary_key: nil)
+      def upload(catalog:, schema:, table:, format:, mode:, file_io:, primary_key: nil, headers: {})
         params = {
           catalog: catalog,
           schema: schema,
@@ -99,36 +99,36 @@ module Altertable
 
         body = file_io.respond_to?(:read) ? file_io.read : file_io
 
-        resp = @adapter.post("/upload", body: body, params: params, headers: { "Content-Type" => "application/octet-stream" })
+        resp = @adapter.post("/upload", body: body, params: params, headers: headers.merge("Content-Type" => "application/octet-stream"))
         handle_response(resp)
       end
 
       # GET /query/:query_id
-      def get_query(query_id)
-        resp = request(:get, "/query/#{query_id}")
+      def get_query(query_id, headers: {})
+        resp = request(:get, "/query/#{query_id}", headers: headers)
         Models::QueryLogResponse.from_h(resp)
       end
 
       # DELETE /query/:query_id
-      def cancel_query(query_id, session_id:)
-        resp = request(:delete, "/query/#{query_id}", query: { session_id: session_id })
+      def cancel_query(query_id, session_id:, headers: {})
+        resp = request(:delete, "/query/#{query_id}", query: { session_id: session_id }, headers: headers)
         Models::CancelQueryResponse.from_h(resp)
       end
 
       # POST /validate
-      def validate(statement:, catalog: nil, schema: nil, session_id: nil)
+      def validate(statement:, catalog: nil, schema: nil, session_id: nil, headers: {})
         req = Models::ValidateRequest.new(
           statement: statement,
           catalog: catalog,
           schema: schema,
           session_id: session_id
         )
-        resp = request(:post, "/validate", body: req.to_h)
+        resp = request(:post, "/validate", body: req.to_h, headers: headers)
         Models::ValidateResponse.from_h(resp)
       end
 
       # POST /autocomplete
-      def autocomplete(statement:, catalog: nil, schema: nil, session_id: nil, max_suggestions: nil)
+      def autocomplete(statement:, catalog: nil, schema: nil, session_id: nil, max_suggestions: nil, headers: {})
         req = Models::AutocompleteRequest.new(
           statement: statement,
           catalog: catalog,
@@ -136,12 +136,12 @@ module Altertable
           session_id: session_id,
           max_suggestions: max_suggestions
         )
-        resp = request(:post, "/autocomplete", body: req.to_h)
+        resp = request(:post, "/autocomplete", body: req.to_h, headers: headers)
         Models::AutocompleteResponse.from_h(resp)
       end
 
       # POST /explain
-      def explain(statement:, catalog: nil, schema: nil, session_id: nil, include_plan: nil)
+      def explain(statement:, catalog: nil, schema: nil, session_id: nil, include_plan: nil, headers: {})
         req = Models::ExplainRequest.new(
           statement: statement,
           catalog: catalog,
@@ -149,7 +149,7 @@ module Altertable
           session_id: session_id,
           include_plan: include_plan
         )
-        resp = request(:post, "/explain", body: req.to_h)
+        resp = request(:post, "/explain", body: req.to_h, headers: headers)
         Models::ExplainResponse.from_h(resp)
       end
 
@@ -182,8 +182,13 @@ module Altertable
         false
       end
 
-      def request(method, path, body: nil, query: nil)
-        resp = @adapter.send(method, path, body: body.is_a?(Hash) ? body.to_json : body, params: query || {})
+      def request(method, path, body: nil, query: nil, headers: {})
+        resp = @adapter.send(
+          method, path,
+          body: body.is_a?(Hash) ? body.to_json : body,
+          params: query || {},
+          headers: headers
+        )
         handle_response(resp)
       end
 

data/lib/altertable/lakehouse/version.rb

@@ -1,5 +1,5 @@
 module Altertable
   module Lakehouse
-    VERSION = "0.4.2"
+    VERSION = "0.5.0"
   end
 end

data/rbi/altertable/lakehouse.rbi

@@ -62,10 +62,11 @@ module Altertable
           base_url: T.nilable(String),
           timeout: T.nilable(T.any(Integer, Float)),
           user_agent: T.nilable(String),
-          adapter: T.nilable(Symbol)
+          adapter: T.nilable(Symbol),
+          headers: T::Hash[String, String]
         ).void
       end
-      def initialize(username: nil, password: nil, basic_auth_token: nil, base_url: nil, timeout: nil, user_agent: nil, adapter: nil); end
+      def initialize(username: nil, password: nil, basic_auth_token: nil, base_url: nil, timeout: nil, user_agent: nil, adapter: nil, headers: {}); end
 
       sig do
         params(
@@ -73,19 +74,20 @@ module Altertable
           schema: String,
           table: String,
           payload: T.any(T::Hash[T.untyped, T.untyped], T::Array[T::Hash[T.untyped, T.untyped]]),
-          sync: T.nilable(T::Boolean)
+          sync: T.nilable(T::Boolean),
+          headers: T::Hash[String, String]
         ).returns(::Altertable::Lakehouse::Models::AppendResponse)
       end
-      def append(catalog:, schema:, table:, payload:, sync: nil); end
+      def append(catalog:, schema:, table:, payload:, sync: nil, headers: {}); end
 
-      sig { params(task_id: String).returns(::Altertable::Lakehouse::Models::TaskResponse) }
-      def get_task(task_id); end
+      sig { params(task_id: String, headers: T::Hash[String, String]).returns(::Altertable::Lakehouse::Models::TaskResponse) }
+      def get_task(task_id, headers: {}); end
 
-      sig { params(statement: String, options: T.untyped).returns(::Altertable::Lakehouse::QueryResult) }
-      def query(statement:, **options); end
+      sig { params(statement: String, headers: T::Hash[String, String], options: T.untyped).returns(::Altertable::Lakehouse::QueryResult) }
+      def query(statement:, headers: {}, **options); end
 
-      sig { params(statement: String, options: T.untyped).returns(T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
-      def query_all(statement:, **options); end
+      sig { params(statement: String, headers: T::Hash[String, String], options: T.untyped).returns(T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      def query_all(statement:, headers: {}, **options); end
 
       sig do
         params(
@@ -95,26 +97,28 @@ module Altertable
           format: String,
           mode: String,
           file_io: T.untyped,
-          primary_key: T.nilable(String)
+          primary_key: T.nilable(String),
+          headers: T::Hash[String, String]
         ).returns(T.untyped)
       end
-      def upload(catalog:, schema:, table:, format:, mode:, file_io:, primary_key: nil); end
+      def upload(catalog:, schema:, table:, format:, mode:, file_io:, primary_key: nil, headers: {}); end
 
-      sig { params(query_id: String).returns(::Altertable::Lakehouse::Models::QueryLogResponse) }
-      def get_query(query_id); end
+      sig { params(query_id: String, headers: T::Hash[String, String]).returns(::Altertable::Lakehouse::Models::QueryLogResponse) }
+      def get_query(query_id, headers: {}); end
 
-      sig { params(query_id: String, session_id: String).returns(::Altertable::Lakehouse::Models::CancelQueryResponse) }
-      def cancel_query(query_id, session_id:); end
+      sig { params(query_id: String, session_id: String, headers: T::Hash[String, String]).returns(::Altertable::Lakehouse::Models::CancelQueryResponse) }
+      def cancel_query(query_id, session_id:, headers: {}); end
 
       sig do
         params(
           statement: String,
           catalog: T.nilable(String),
           schema: T.nilable(String),
-          session_id: T.nilable(String)
+          session_id: T.nilable(String),
+          headers: T::Hash[String, String]
         ).returns(::Altertable::Lakehouse::Models::ValidateResponse)
       end
-      def validate(statement:, catalog: nil, schema: nil, session_id: nil); end
+      def validate(statement:, catalog: nil, schema: nil, session_id: nil, headers: {}); end
 
       sig do
         params(
@@ -122,10 +126,11 @@ module Altertable
           catalog: T.nilable(String),
           schema: T.nilable(String),
           session_id: T.nilable(String),
-          max_suggestions: T.nilable(Integer)
+          max_suggestions: T.nilable(Integer),
+          headers: T::Hash[String, String]
         ).returns(::Altertable::Lakehouse::Models::AutocompleteResponse)
       end
-      def autocomplete(statement:, catalog: nil, schema: nil, session_id: nil, max_suggestions: nil); end
+      def autocomplete(statement:, catalog: nil, schema: nil, session_id: nil, max_suggestions: nil, headers: {}); end
 
       sig do
         params(
@@ -133,10 +138,11 @@ module Altertable
           catalog: T.nilable(String),
           schema: T.nilable(String),
           session_id: T.nilable(String),
-          include_plan: T.nilable(T::Boolean)
+          include_plan: T.nilable(T::Boolean),
+          headers: T::Hash[String, String]
         ).returns(::Altertable::Lakehouse::Models::ExplainResponse)
       end
-      def explain(statement:, catalog: nil, schema: nil, session_id: nil, include_plan: nil); end
+      def explain(statement:, catalog: nil, schema: nil, session_id: nil, include_plan: nil, headers: {}); end
 
       private
 
@@ -151,10 +157,11 @@ module Altertable
           method: Symbol,
           path: String,
           body: T.untyped,
-          query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped])
+          query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+          headers: T::Hash[String, String]
         ).returns(T.untyped)
       end
-      def request(method, path, body: nil, query: nil); end
+      def request(method, path, body: nil, query: nil, headers: {}); end
 
       sig { params(resp: ::Altertable::Lakehouse::Adapters::Response, buffer: String, yielder: Enumerator::Yielder).void }
       def handle_stream_response(resp, buffer, yielder); end

data/sig/altertable/lakehouse/client.rbs

@@ -17,7 +17,8 @@ module Altertable
         ?base_url: String?,
         ?timeout: Integer | Float?,
         ?user_agent: String?,
-        ?adapter: Symbol?
+        ?adapter: Symbol?,
+        ?headers: ::Hash[String, String]
       ) -> void
 
       def append: (
@@ -25,14 +26,15 @@ module Altertable
         schema: String,
         table: String,
         payload: ::Hash[untyped, untyped] | ::Array[::Hash[untyped, untyped]],
-        ?sync: bool?
+        ?sync: bool?,
+        ?headers: ::Hash[String, String]
       ) -> Models::AppendResponse
 
-      def get_task: (String task_id) -> Models::TaskResponse
+      def get_task: (String task_id, ?headers: ::Hash[String, String]) -> Models::TaskResponse
 
-      def query: (statement: String, **untyped options) -> QueryResult
+      def query: (statement: String, ?headers: ::Hash[String, String], **untyped options) -> QueryResult
 
-      def query_all: (statement: String, **untyped options) -> ::Hash[Symbol, untyped]
+      def query_all: (statement: String, ?headers: ::Hash[String, String], **untyped options) -> ::Hash[Symbol, untyped]
 
       def upload: (
         catalog: String,
@@ -41,18 +43,20 @@ module Altertable
         format: String,
         mode: String,
         file_io: untyped,
-        ?primary_key: String?
+        ?primary_key: String?,
+        ?headers: ::Hash[String, String]
       ) -> untyped
 
-      def get_query: (String query_id) -> Models::QueryLogResponse
+      def get_query: (String query_id, ?headers: ::Hash[String, String]) -> Models::QueryLogResponse
 
-      def cancel_query: (String query_id, session_id: String) -> Models::CancelQueryResponse
+      def cancel_query: (String query_id, session_id: String, ?headers: ::Hash[String, String]) -> Models::CancelQueryResponse
 
       def validate: (
         statement: String,
         ?catalog: String?,
         ?schema: String?,
-        ?session_id: String?
+        ?session_id: String?,
+        ?headers: ::Hash[String, String]
       ) -> Models::ValidateResponse
 
       def autocomplete: (
@@ -60,7 +64,8 @@ module Altertable
         ?catalog: String?,
         ?schema: String?,
         ?session_id: String?,
-        ?max_suggestions: Integer?
+        ?max_suggestions: Integer?,
+        ?headers: ::Hash[String, String]
       ) -> Models::AutocompleteResponse
 
       def explain: (
@@ -68,14 +73,21 @@ module Altertable
         ?catalog: String?,
         ?schema: String?,
         ?session_id: String?,
-        ?include_plan: bool?
+        ?include_plan: bool?,
+        ?headers: ::Hash[String, String]
       ) -> Models::ExplainResponse
 
       private
 
       def select_adapter: (Symbol? name, untyped options) -> untyped
       def try_require: (String gem_name) -> bool
-      def request: (Symbol method, String path, ?body: untyped, ?query: ::Hash[Symbol | String, untyped]?) -> untyped
+      def request: (
+        Symbol method,
+        String path,
+        ?body: untyped,
+        ?query: ::Hash[Symbol | String, untyped]?,
+        ?headers: ::Hash[String, String]
+      ) -> untyped
       def handle_stream_response: (Adapters::Response resp, String buffer, Enumerator::Yielder yielder) -> void
       def handle_response: (Adapters::Response resp) -> untyped
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: altertable-lakehouse
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Altertable AI