tina4-ultipa 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78beafa9836b0d709d9a02d788ca1bd25bed6e75a8d72b59c28fd07f777ea566
-  data.tar.gz: f367219bedd06967311975326649f6507bace52a439147866bb4144eb96289e1
+  metadata.gz: db28f1b774ee4b89511ce92be09703eafcee240f8d365434b65b33aa7b68ac15
+  data.tar.gz: 1a35099dd84422f8047c1f3cb5867c1083c6a454635a83019e7f5bc87b71059a
 SHA512:
-  metadata.gz: 07db5593de9c6a3e6ece49e205263f962ddbafb00b07831a592999c81e5873057b13f8a7b927c60b166138ad326e412cf84239bda016b7876b1d8d56de7bc850
-  data.tar.gz: 22ef4d3cf031368ec8524c082178eb178614cd218b43773938df54f34efa9e25955177bccdd7d7712dcf8563ca8349ba2bc0afebb289b8cf06f8b4ed61b59ea9
+  metadata.gz: 57a742e80ccc65b03794cf907ac37dc3cd5d723fcb18a37c2e25cb1375d57a327a17ab949e54e6de73f612ed9de61c01a240b6bb1f55b9230998a9d39ae43f36
+  data.tar.gz: 41b7a417fbe6a8eaceb481a26f7cc556cea14fba09025ff94419a31c36f3e62fe5544ef7d6d752d5142c6937851e9c2784090672139c39d2b58f46584f341190

data/lib/tina4_ultipa/client.rb

@@ -6,17 +6,16 @@
 # then that id rides every call as the gRPC metadata header `session-id`.
 # Query: QueryService.Gql(GqlRequest) -> GqlResponse. This is the whole surface the
 # Tina4 graph adapter needs; node/edge/traverse are built in GQL on top of query.
+#
+# Wire stack (pure Ruby, no C extensions, no google-protobuf):
+#   * `http-2` gem drives HTTP/2 framing (HPACK, streams, flow control)
+#   * lib/tina4_ultipa/grpc.rb wraps that in gRPC framing (unary_unary only)
+#   * lib/tina4_ultipa/pb.rb hand-rolls proto3 for the 8 gqldb messages
 
 require "uri"
-require "grpc"
-
-# The generated stubs `require 'gqldb_pb'` / `require 'gqldb_services_pb'` by bare
-# name, so put their directory on the load path before requiring them.
-_gen_dir = File.expand_path("gen", __dir__)
-$LOAD_PATH.unshift(_gen_dir) unless $LOAD_PATH.include?(_gen_dir)
-require "gqldb_pb"
-require "gqldb_services_pb"
 
+require_relative "pb"
+require_relative "grpc"
 require_relative "codec"
 require_relative "errors"
 
@@ -38,14 +37,9 @@ module Tina4Ultipa
       @warnings = resp.warnings.to_a
       @current_graph = resp.current_graph
       d = resp.dml_stats
-      @dml_stats = if d
-                     { inserted_nodes: d.inserted_nodes, inserted_edges: d.inserted_edges,
-                       deleted_nodes: d.deleted_nodes, deleted_edges: d.deleted_edges,
-                       set_nodes: d.set_nodes, set_edges: d.set_edges }
-                   else
-                     { inserted_nodes: 0, inserted_edges: 0, deleted_nodes: 0,
-                       deleted_edges: 0, set_nodes: 0, set_edges: 0 }
-                   end
+      @dml_stats = { inserted_nodes: d.inserted_nodes, inserted_edges: d.inserted_edges,
+                     deleted_nodes: d.deleted_nodes, deleted_edges: d.deleted_edges,
+                     set_nodes: d.set_nodes, set_edges: d.set_edges }
     end
 
     # Rows as hashes keyed by column name.
@@ -85,8 +79,6 @@ module Tina4Ultipa
       @connect_timeout = connect_timeout.to_f
       @use_tls = use_tls
       @channel = nil
-      @session = nil
-      @query = nil
       @session_id = nil
       @server_version = nil
     end
@@ -112,25 +104,38 @@ module Tina4Ultipa
     def connect
       return self unless @session_id.nil?
 
-      target = "#{@host}:#{@port}"
-      creds = @use_tls ? GRPC::Core::ChannelCredentials.new : :this_channel_is_insecure
-      @channel = GRPC::Core::Channel.new(target, nil, creds)
+      @channel = GrpcClient::Channel.new(
+        @host, @port, use_tls: @use_tls, connect_timeout: @connect_timeout,
+      )
       started = monotonic
-      wait_for_ready(@channel, started)
+      begin
+        @channel.connect
+      rescue GrpcClient::ConnectTimeout => e
+        elapsed = monotonic - started
+        close
+        raise ConnectError.new(@host, @port, elapsed, cause: e)
+      end
 
-      @session = Gqldb::SessionService::Stub.new(target, creds, channel_override: @channel)
-      @query = Gqldb::QueryService::Stub.new(target, creds, channel_override: @channel)
+      req = Gqldb::LoginRequest.new(
+        username: @username || "", password: @password || "",
+        default_graph: @graph,
+      )
       begin
-        resp = @session.login(
-          Gqldb::LoginRequest.new(
-            username: @username || "", password: @password || "", default_graph: @graph,
-          ),
-          deadline: Time.now + @connect_timeout,
+        resp_bytes = @channel.unary(
+          "/gqldb.SessionService/Login",
+          Gqldb::LoginRequest.encode(req),
+          timeout: @connect_timeout,
         )
-      rescue GRPC::BadStatus => e
+      rescue GrpcClient::RpcError => e
         close
         raise wrap(e, "login failed")
+      rescue GrpcClient::ConnectTimeout => e
+        elapsed = monotonic - started
+        close
+        raise ConnectError.new(@host, @port, elapsed, cause: e)
       end
+
+      resp = Gqldb::LoginResponse.decode(resp_bytes)
       @session_id = resp.session_id
       @server_version = resp.server_version
       self
@@ -152,11 +157,16 @@ module Tina4Ultipa
         timeout: timeout ? timeout.to_i : 0,
       )
       begin
-        resp = @query.gql(req, metadata: { "session-id" => @session_id.to_s })
-      rescue GRPC::BadStatus => e
+        resp_bytes = @channel.unary(
+          "/gqldb.QueryService/Gql",
+          Gqldb::GqlRequest.encode(req),
+          metadata: { "session-id" => @session_id.to_s },
+          timeout: timeout ? timeout.to_f : nil,
+        )
+      rescue GrpcClient::RpcError => e
         raise wrap(e, "gql failed")
       end
-      Result.new(resp)
+      Result.new(Gqldb::GqlResponse.decode(resp_bytes))
     end
 
     # Run a writing GQL statement (read_only = false).
@@ -165,11 +175,12 @@ module Tina4Ultipa
     end
 
     def close
-      @channel.close if @channel.respond_to?(:close)
+      @channel&.close
     rescue StandardError
       # best effort - the channel is being torn down regardless
     ensure
-      @channel = @session = @query = @session_id = nil
+      @channel = nil
+      @session_id = nil
     end
 
     private
@@ -178,28 +189,9 @@ module Tina4Ultipa
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def wait_for_ready(channel, started)
-      states = GRPC::Core::ConnectivityStates
-      deadline = Time.now + @connect_timeout
-      state = channel.connectivity_state(true)
-      until state == states::READY
-        break if Time.now >= deadline
-
-        channel.watch_connectivity_state(state, deadline)
-        state = channel.connectivity_state(true)
-      end
-      return if state == states::READY
-
-      elapsed = monotonic - started
-      close
-      raise ConnectError.new(@host, @port, elapsed)
-    end
-
     def wrap(rpc_error, prefix)
-      detail = rpc_error.respond_to?(:details) ? rpc_error.details : nil
-      detail = rpc_error.message if detail.nil? || detail.to_s.empty?
-      code = rpc_error.class.name.to_s.split("::").last
-      Error.new("#{prefix}: #{detail}", code: code, cause: rpc_error)
+      code = rpc_error.respond_to?(:status_name) ? rpc_error.status_name : nil
+      Error.new("#{prefix}: #{rpc_error.message}", code: code, cause: rpc_error)
     end
   end
 end

data/lib/tina4_ultipa/codec.rb

@@ -2,6 +2,8 @@
 
 require "json"
 
+require_relative "pb"
+
 # Encode/decode gqldb TypedValue <-> Ruby values.
 #
 # Grounded against the official gqldb-nodejs SDK decoder and verified live against

data/lib/tina4_ultipa/grpc.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "socket"
+require "openssl"
+require "http/2"
+
+# Minimal gRPC-over-HTTP/2 client for this driver's 2 unary RPCs.
+#
+# We ride the pure-Ruby `http-2` gem (no C extensions, no google-protobuf
+# transitive dep) and wrap it in the gRPC framing convention:
+#
+#     +--------+------------+---------+
+#     | 0x00   | u32 BE len | payload |    (compressed flag = 0 = uncompressed)
+#     +--------+------------+---------+
+#
+# The response comes back the same way, with the RPC outcome in HTTP/2
+# trailers as `grpc-status: N` and optionally `grpc-message: text`.
+#
+# Only unary_unary is supported - streaming RPCs (server/client/bidi) are not
+# used by gqldb's Login/Gql surface. Adding them is a self-contained extension.
+
+module Tina4Ultipa
+  module GrpcClient
+    # Raised by Channel#unary when the peer returns a non-OK grpc-status trailer.
+    class RpcError < StandardError
+      attr_reader :status_code, :status_name
+
+      GRPC_STATUS_NAMES = {
+        0 => "OK", 1 => "CANCELLED", 2 => "UNKNOWN", 3 => "INVALID_ARGUMENT",
+        4 => "DEADLINE_EXCEEDED", 5 => "NOT_FOUND", 6 => "ALREADY_EXISTS",
+        7 => "PERMISSION_DENIED", 8 => "RESOURCE_EXHAUSTED", 9 => "FAILED_PRECONDITION",
+        10 => "ABORTED", 11 => "OUT_OF_RANGE", 12 => "UNIMPLEMENTED",
+        13 => "INTERNAL", 14 => "UNAVAILABLE", 15 => "DATA_LOSS",
+        16 => "UNAUTHENTICATED",
+      }.freeze
+
+      def initialize(status_code, message)
+        @status_code = status_code
+        @status_name = GRPC_STATUS_NAMES[status_code] || "STATUS_#{status_code}"
+        super("gRPC #{@status_name}: #{message}")
+      end
+    end
+
+    # Raised when the socket connect / TLS handshake times out. Callers translate
+    # this into their own ConnectError with the elapsed time.
+    class ConnectTimeout < StandardError; end
+
+    # A single HTTP/2 connection to a gqldb host. Not thread-safe; use one
+    # Channel per Client instance.
+    class Channel
+      READ_CHUNK = 16_384
+
+      def initialize(host, port, use_tls: false, connect_timeout: 10.0)
+        @host = host
+        @port = port.to_i
+        @use_tls = use_tls
+        @connect_timeout = connect_timeout.to_f
+        @socket = nil
+        @client = nil
+        @closed = false
+      end
+
+      def connect
+        return self if @socket
+
+        deadline = monotonic + @connect_timeout
+
+        # Plain TCP connect with a wall-clock deadline. Socket.tcp handles
+        # IPv4/IPv6 fallback; a bare TCPSocket does not.
+        begin
+          @socket = Socket.tcp(@host, @port, connect_timeout: @connect_timeout)
+        rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH,
+               Errno::ENETUNREACH, SocketError => e
+          raise ConnectTimeout, "tcp: #{e.class}: #{e.message}"
+        end
+
+        if @use_tls
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.alpn_protocols = ["h2"]
+          @socket = OpenSSL::SSL::SSLSocket.new(@socket, ctx)
+          @socket.sync_close = true
+          @socket.hostname = @host
+          begin
+            @socket.connect
+          rescue OpenSSL::SSL::SSLError => e
+            raise ConnectTimeout, "tls: #{e.message}"
+          end
+          if @socket.respond_to?(:alpn_protocol) && @socket.alpn_protocol != "h2"
+            raise ConnectTimeout, "alpn: server did not select h2"
+          end
+        end
+
+        # http-2's Client emits :frame events with encoded HTTP/2 frames.
+        # Write them straight to the socket. All inbound bytes get fed back
+        # via `client << data`, which raises the state-machine events on
+        # the stream we open. The client preface + initial SETTINGS fires
+        # automatically the first time we emit a frame in `unary`, so there
+        # is nothing to do here beyond having a live socket + a Client
+        # instance ready to receive callbacks.
+        @client = HTTP2::Client.new
+        @client.on(:frame) { |bytes| @socket.write(bytes) }
+        self
+      end
+
+      # unary(method, payload_bytes, metadata:, timeout:) -> response payload bytes
+      #
+      # Raises RpcError on non-OK grpc-status, ConnectTimeout on connect/read
+      # deadline overrun.
+      def unary(method, payload, metadata: {}, timeout: nil)
+        connect
+        deadline = timeout ? monotonic + timeout.to_f : nil
+
+        headers = {
+          ":method" => "POST",
+          ":scheme" => @use_tls ? "https" : "http",
+          ":path" => method,
+          ":authority" => "#{@host}:#{@port}",
+          "content-type" => "application/grpc+proto",
+          "te" => "trailers",
+          "user-agent" => "tina4-ultipa-ruby/0.2 http-2",
+        }
+        metadata.each { |k, v| headers[k.to_s.downcase] = v.to_s }
+
+        stream = @client.new_stream
+
+        resp_status = nil
+        resp_message = nil
+        resp_body = "".b
+        stream_closed = false
+        rst_reason = nil
+
+        stream.on(:headers) do |h|
+          h.each do |k, v|
+            case k
+            when "grpc-status"  then resp_status = v.to_i
+            when "grpc-message" then resp_message = v
+            end
+          end
+        end
+        stream.on(:data) { |d| resp_body << d.b }
+        stream.on(:close) { stream_closed = true }
+        stream.on(:reset) { |code| rst_reason = code; stream_closed = true }
+
+        stream.headers(headers, end_stream: false)
+        stream.data(frame_encode(payload), end_stream: true)
+
+        drain_until(deadline) { stream_closed }
+
+        if rst_reason
+          raise RpcError.new(2, "stream reset (#{rst_reason})")
+        end
+        # No grpc-status trailer at all is a protocol violation (or the server
+        # closed the connection); surface as UNKNOWN so the caller sees why.
+        if resp_status.nil?
+          raise RpcError.new(2, "no grpc-status trailer (server may have closed)")
+        end
+        unless resp_status.zero?
+          raise RpcError.new(resp_status, resp_message || "")
+        end
+
+        frame_decode(resp_body)
+      end
+
+      def close
+        return if @closed
+
+        @closed = true
+        @socket&.close rescue nil
+        @socket = nil
+        @client = nil
+      end
+
+      private
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      # Drive the read side until the block returns true or the deadline elapses.
+      def drain_until(deadline)
+        loop do
+          return if yield
+
+          remaining = deadline ? deadline - monotonic : nil
+          raise ConnectTimeout, "read deadline" if remaining && remaining <= 0
+
+          ready = IO.select([@socket], nil, nil, remaining)
+          raise ConnectTimeout, "read deadline" if ready.nil?
+
+          chunk = read_available
+          break if chunk.nil? || chunk.empty?
+
+          @client << chunk
+        end
+      end
+
+      def read_available
+        # SSLSocket buffers ciphertext internally; readpartial returns whatever
+        # plaintext is available. On plain TCP, readpartial blocks until any
+        # byte arrives (we already selected, so at least one is ready).
+        @socket.readpartial(READ_CHUNK)
+      rescue EOFError
+        nil
+      end
+
+      # gRPC frame = 1 byte flag (0 = uncompressed) + u32 BE length + payload.
+      def frame_encode(payload)
+        "\x00".b + [payload.bytesize].pack("N") + payload.b
+      end
+
+      # Decode ONE gRPC frame. Unary responses ship exactly one frame; if the
+      # server ever streams multiple frames back, extend this to loop.
+      def frame_decode(bytes)
+        raise RpcError.new(2, "short gRPC frame (#{bytes.bytesize} bytes)") if bytes.bytesize < 5
+
+        _flag = bytes.getbyte(0)
+        len = bytes.byteslice(1, 4).unpack1("N")
+        if bytes.bytesize < 5 + len
+          raise RpcError.new(2, "truncated gRPC frame (want #{5 + len}, got #{bytes.bytesize})")
+        end
+
+        bytes.byteslice(5, len).b
+      end
+    end
+  end
+end

data/lib/tina4_ultipa/pb.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+# Hand-rolled proto3 wire codec for the gqldb messages this driver uses.
+#
+# The `grpc` gem calls MessageClass.encode(msg) and MessageClass.decode(bytes)
+# on whatever class we register with the stub. We supply those two class
+# methods so grpc has no idea protobuf isn't in the loop. No google-protobuf
+# runtime, no descriptor pool, no generated stubs.
+#
+# What we speak:
+#   Envelopes:  LoginRequest / LoginResponse / GqlRequest / GqlResponse
+#   Nested:     Parameter / TypedValue / Row / DmlStats
+#   Enum:       PropertyType (integer constants + symbol lookup for codec parity)
+#
+# Proto3 rules we honour:
+#   * default scalar values are NOT written to the wire
+#   * unknown fields on read are skipped (server may add fields; we ignore them)
+#   * repeated scalar strings/bytes/messages are NOT packed (one tag per element)
+#   * repeated numeric scalars would be packed - this schema has none
+#
+# NOT implemented (gqldb.proto does not use them; adding any is a self-contained
+# ~15-line extension):
+#   oneof, map<>, Any, packed scalars, groups, edition-2023 features.
+
+module Gqldb
+  # PropertyType. Integer constants + symbol<->int lookups. Codec speaks symbols,
+  # wire speaks integers.
+  module PropertyType
+    NAMES = {
+       0 => :PROPERTY_TYPE_UNSET,
+       1 => :PROPERTY_TYPE_INT32,
+       2 => :PROPERTY_TYPE_UINT32,
+       3 => :PROPERTY_TYPE_INT64,
+       4 => :PROPERTY_TYPE_UINT64,
+       5 => :PROPERTY_TYPE_FLOAT,
+       6 => :PROPERTY_TYPE_DOUBLE,
+       7 => :PROPERTY_TYPE_STRING,
+       8 => :PROPERTY_TYPE_DATETIME,
+       9 => :PROPERTY_TYPE_TIMESTAMP,
+      10 => :PROPERTY_TYPE_TEXT,
+      11 => :PROPERTY_TYPE_BLOB,
+      12 => :PROPERTY_TYPE_POINT,
+      13 => :PROPERTY_TYPE_DECIMAL,
+      14 => :PROPERTY_TYPE_LIST,
+      15 => :PROPERTY_TYPE_SET,
+      16 => :PROPERTY_TYPE_MAP,
+      17 => :PROPERTY_TYPE_NULL,
+      18 => :PROPERTY_TYPE_BOOL,
+      19 => :PROPERTY_TYPE_LOCAL_DATETIME,
+      20 => :PROPERTY_TYPE_ZONED_DATETIME,
+      21 => :PROPERTY_TYPE_DATE,
+      22 => :PROPERTY_TYPE_ZONED_TIME,
+      23 => :PROPERTY_TYPE_LOCAL_TIME,
+      24 => :PROPERTY_TYPE_YEAR_TO_MONTH,
+      25 => :PROPERTY_TYPE_DAY_TO_SECOND,
+      26 => :PROPERTY_TYPE_RECORD,
+      27 => :PROPERTY_TYPE_POINT3D,
+      28 => :PROPERTY_TYPE_VECTOR,
+      29 => :PROPERTY_TYPE_TABLE,
+      30 => :PROPERTY_TYPE_PATH,
+      31 => :PROPERTY_TYPE_ERROR,
+      32 => :PROPERTY_TYPE_NODE,
+      33 => :PROPERTY_TYPE_EDGE,
+    }.freeze
+    IDS = NAMES.invert.freeze
+
+    def self.id_of(sym_or_int)
+      return sym_or_int if sym_or_int.is_a?(Integer)
+      IDS[sym_or_int] || 0
+    end
+
+    def self.name_of(int_or_sym)
+      return int_or_sym if int_or_sym.is_a?(Symbol)
+      NAMES[int_or_sym] || int_or_sym
+    end
+  end
+
+  # ---- wire encoders --------------------------------------------------------
+  module Wire
+    module_function
+
+    def varint(buf, n)
+      # Handle negative numbers as two's-complement uint64.
+      n = (1 << 64) + n if n.negative?
+      while n >= 0x80
+        buf << ((n & 0x7F) | 0x80)
+        n >>= 7
+      end
+      buf << (n & 0x7F)
+    end
+
+    def tag(buf, field_no, wire_type)
+      varint(buf, (field_no << 3) | wire_type)
+    end
+
+    def write_bytes(buf, field_no, bytes)
+      return if bytes.nil? || bytes.empty?
+      tag(buf, field_no, 2)
+      varint(buf, bytes.bytesize)
+      buf << bytes.b
+    end
+
+    def write_string(buf, field_no, str)
+      return if str.nil? || str.empty?
+      write_bytes(buf, field_no, str.dup.force_encoding("BINARY"))
+    end
+
+    def write_varint(buf, field_no, n)
+      return if n.zero?
+      tag(buf, field_no, 0)
+      varint(buf, n)
+    end
+
+    def write_bool(buf, field_no, b)
+      return unless b
+      tag(buf, field_no, 0)
+      varint(buf, 1)
+    end
+  end
+
+  # ---- wire reader ----------------------------------------------------------
+  class Reader
+    def initialize(bytes)
+      @b = bytes.dup.force_encoding("BINARY")
+      @p = 0
+      @end = @b.bytesize
+    end
+
+    def eof?
+      @p >= @end
+    end
+
+    def read_varint
+      r = 0
+      sh = 0
+      loop do
+        byte = @b.getbyte(@p)
+        @p += 1
+        r |= (byte & 0x7F) << sh
+        return r if (byte & 0x80).zero?
+        sh += 7
+      end
+    end
+
+    def read_signed_varint
+      v = read_varint
+      v -= (1 << 64) if v >= (1 << 63)
+      v
+    end
+
+    def read_len
+      n = read_varint
+      s = @b.byteslice(@p, n) || ""
+      @p += n
+      s.dup.force_encoding("BINARY")
+    end
+
+    def read_string
+      read_len.force_encoding("UTF-8")
+    end
+
+    def skip(wire_type)
+      case wire_type
+      when 0 then read_varint
+      when 2 then @p += read_varint
+      when 5 then @p += 4
+      when 1 then @p += 8
+      else raise ArgumentError, "unknown wire type #{wire_type}"
+      end
+    end
+  end
+
+  # ---- messages -------------------------------------------------------------
+
+  class TypedValue
+    attr_accessor :type, :data, :is_null
+
+    def initialize(type: 0, data: "".b, is_null: false)
+      @type = PropertyType.id_of(type)
+      @data = (data || "".b).dup.force_encoding("BINARY")
+      @is_null = is_null
+    end
+
+    def self.encode(msg)
+      buf = "".b
+      Wire.write_varint(buf, 1, msg.type)
+      Wire.write_bytes(buf, 2, msg.data)
+      Wire.write_bool(buf, 3, msg.is_null)
+      buf
+    end
+
+    def self.decode(bytes)
+      o = new
+      r = Reader.new(bytes)
+      until r.eof?
+        tag = r.read_varint
+        fn = tag >> 3
+        wt = tag & 7
+        if    fn == 1 && wt == 0 then o.type = r.read_varint
+        elsif fn == 2 && wt == 2 then o.data = r.read_len
+        elsif fn == 3 && wt == 0 then o.is_null = !r.read_varint.zero?
+        else r.skip(wt)
+        end
+      end
+      o
+    end
+  end
+
+  class Parameter
+    attr_accessor :name, :value
+
+    def initialize(name: "", value: TypedValue.new)
+      @name = name.to_s
+      @value = value
+    end
+
+    def self.encode(msg)
+      buf = "".b
+      Wire.write_string(buf, 1, msg.name)
+      inner = TypedValue.encode(msg.value)
+      Wire.write_bytes(buf, 2, inner)
+      buf
+    end
+  end
+
+  class Row
+    attr_accessor :values
+
+    def initialize(values: [])
+      @values = values
+    end
+
+    def self.decode(bytes)
+      o = new
+      r = Reader.new(bytes)
+      until r.eof?
+        tag = r.read_varint
+        fn = tag >> 3
+        wt = tag & 7
+        if fn == 1 && wt == 2
+          o.values << TypedValue.decode(r.read_len)
+        else
+          r.skip(wt)
+        end
+      end
+      o
+    end
+  end
+
+  class DmlStats
+    attr_accessor :inserted_nodes, :inserted_edges, :deleted_nodes,
+                  :deleted_edges, :set_nodes, :set_edges
+
+    def initialize(inserted_nodes: 0, inserted_edges: 0, deleted_nodes: 0,
+                   deleted_edges: 0, set_nodes: 0, set_edges: 0)
+      @inserted_nodes = inserted_nodes
+      @inserted_edges = inserted_edges
+      @deleted_nodes = deleted_nodes
+      @deleted_edges = deleted_edges
+      @set_nodes = set_nodes
+      @set_edges = set_edges
+    end
+
+    def self.decode(bytes)
+      o = new
+      r = Reader.new(bytes)
+      until r.eof?
+        tag = r.read_varint
+        fn = tag >> 3
+        wt = tag & 7
+        (r.skip(wt); next) if wt != 0
+        v = r.read_signed_varint
+        case fn
+        when 1 then o.inserted_nodes = v
+        when 2 then o.inserted_edges = v
+        when 3 then o.deleted_nodes = v
+        when 4 then o.deleted_edges = v
+        when 5 then o.set_nodes = v
+        when 6 then o.set_edges = v
+        end
+      end
+      o
+    end
+  end
+
+  class LoginRequest
+    attr_accessor :username, :password, :default_graph
+
+    def initialize(username: "", password: "", default_graph: "")
+      @username = username
+      @password = password
+      @default_graph = default_graph
+    end
+
+    def self.encode(msg)
+      buf = "".b
+      Wire.write_string(buf, 1, msg.username)
+      Wire.write_string(buf, 2, msg.password)
+      Wire.write_string(buf, 3, msg.default_graph)
+      buf
+    end
+  end
+
+  class LoginResponse
+    attr_accessor :session_id, :server_version, :roles, :is_cluster,
+                  :cluster_id, :partition_count, :capabilities,
+                  :current_graph, :time_cost_ns, :disk_cost_ns, :compute_cost_ns
+
+    def initialize
+      @session_id = 0
+      @server_version = ""
+      @roles = []
+      @is_cluster = false
+      @cluster_id = ""
+      @partition_count = 0
+      @capabilities = []
+      @current_graph = ""
+      @time_cost_ns = 0
+      @disk_cost_ns = 0
+      @compute_cost_ns = 0
+    end
+
+    def self.decode(bytes)
+      o = new
+      r = Reader.new(bytes)
+      until r.eof?
+        tag = r.read_varint
+        fn = tag >> 3
+        wt = tag & 7
+        case [fn, wt]
+        when [1, 0]  then o.session_id = r.read_varint
+        when [2, 2]  then o.server_version = r.read_string
+        when [3, 2]  then o.roles << r.read_string
+        when [10, 0] then o.is_cluster = !r.read_varint.zero?
+        when [11, 2] then o.cluster_id = r.read_string
+        when [12, 0] then o.partition_count = r.read_signed_varint
+        when [20, 2] then o.capabilities << r.read_string
+        when [21, 2] then o.current_graph = r.read_string
+        when [22, 0] then o.time_cost_ns = r.read_signed_varint
+        when [23, 0] then o.disk_cost_ns = r.read_signed_varint
+        when [24, 0] then o.compute_cost_ns = r.read_signed_varint
+        else r.skip(wt)
+        end
+      end
+      o
+    end
+  end
+
+  class GqlRequest
+    attr_accessor :gql, :graph_name, :parameters, :session_id,
+                  :transaction_id, :timeout, :read_only, :max_path_results
+
+    def initialize(gql: "", graph_name: "", parameters: [], session_id: 0,
+                   transaction_id: 0, timeout: 0, read_only: false,
+                   max_path_results: 0)
+      @gql = gql
+      @graph_name = graph_name
+      @parameters = parameters
+      @session_id = session_id
+      @transaction_id = transaction_id
+      @timeout = timeout
+      @read_only = read_only
+      @max_path_results = max_path_results
+    end
+
+    def self.encode(msg)
+      buf = "".b
+      Wire.write_string(buf, 1, msg.gql)
+      Wire.write_string(buf, 2, msg.graph_name)
+      msg.parameters.each do |p|
+        Wire.write_bytes(buf, 3, Parameter.encode(p))
+      end
+      Wire.write_varint(buf, 4, msg.session_id)
+      Wire.write_varint(buf, 5, msg.transaction_id)
+      Wire.write_varint(buf, 6, msg.timeout)
+      Wire.write_bool(buf, 7, msg.read_only)
+      Wire.write_varint(buf, 8, msg.max_path_results)
+      buf
+    end
+  end
+
+  class GqlResponse
+    attr_accessor :columns, :rows, :row_count, :has_more, :warnings,
+                  :rows_affected, :current_graph, :time_cost_ns,
+                  :disk_cost_ns, :compute_cost_ns, :dml_stats
+
+    def initialize
+      @columns = []
+      @rows = []
+      @row_count = 0
+      @has_more = false
+      @warnings = []
+      @rows_affected = 0
+      @current_graph = ""
+      @time_cost_ns = 0
+      @disk_cost_ns = 0
+      @compute_cost_ns = 0
+      @dml_stats = DmlStats.new
+    end
+
+    def self.decode(bytes)
+      o = new
+      r = Reader.new(bytes)
+      until r.eof?
+        tag = r.read_varint
+        fn = tag >> 3
+        wt = tag & 7
+        case [fn, wt]
+        when [1, 2]  then o.columns << r.read_string
+        when [2, 2]  then o.rows << Row.decode(r.read_len)
+        when [3, 0]  then o.row_count = r.read_signed_varint
+        when [4, 0]  then o.has_more = !r.read_varint.zero?
+        when [5, 2]  then o.warnings << r.read_string
+        when [6, 0]  then o.rows_affected = r.read_signed_varint
+        when [7, 2]  then o.current_graph = r.read_string
+        when [8, 0]  then o.time_cost_ns = r.read_signed_varint
+        when [9, 0]  then o.disk_cost_ns = r.read_signed_varint
+        when [10, 0] then o.compute_cost_ns = r.read_signed_varint
+        when [11, 2] then o.dml_stats = DmlStats.decode(r.read_len)
+        else r.skip(wt)
+        end
+      end
+      o
+    end
+  end
+end

data/lib/tina4_ultipa/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4Ultipa
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/tina4-ultipa.gemspec

@@ -28,6 +28,9 @@ Gem::Specification.new do |spec|
   ]
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "google-protobuf", ">= 3.25"
-  spec.add_dependency "grpc", ">= 1.60"
+  # Pure-Ruby HTTP/2. Zero C extensions, zero google-protobuf, zero
+  # transitive deps. See lib/tina4_ultipa/grpc.rb for the tiny gRPC framing
+  # layer on top of it, and lib/tina4_ultipa/pb.rb for the hand-rolled
+  # proto3 wire codec for the 8 gqldb messages we consume.
+  spec.add_dependency "http-2", ">= 1.2"
 end

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tina4-ultipa
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tina4 Stack
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-21 00:00:00.000000000 Z
+date: 2026-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: google-protobuf
+  name: http-2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.25'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.25'
-- !ruby/object:Gem::Dependency
-  name: grpc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.60'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.60'
+        version: '1.2'
 description: A thin, standalone gRPC client for the Ultipa graph database (ultipa-gqldb)
   - the Ultipa driver behind Tina4's graph layer, usable on its own.
 email:
@@ -52,8 +38,8 @@ files:
 - lib/tina4_ultipa/client.rb
 - lib/tina4_ultipa/codec.rb
 - lib/tina4_ultipa/errors.rb
-- lib/tina4_ultipa/gen/gqldb_pb.rb
-- lib/tina4_ultipa/gen/gqldb_services_pb.rb
+- lib/tina4_ultipa/grpc.rb
+- lib/tina4_ultipa/pb.rb
 - lib/tina4_ultipa/version.rb
 - proto/gqldb.proto
 - tina4-ultipa.gemspec

data/lib/tina4_ultipa/gen/gqldb_pb.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: gqldb.proto
-
-require 'google/protobuf'
-
-
-descriptor_data = "\n\x0bgqldb.proto\x12\x05gqldb\"N\n\nTypedValue\x12!\n\x04type\x18\x01 \x01(\x0e\x32\x13.gqldb.PropertyType\x12\x0c\n\x04\x64\x61ta\x18\x02 \x01(\x0c\x12\x0f\n\x07is_null\x18\x03 \x01(\x08\";\n\tParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12 \n\x05value\x18\x02 \x01(\x0b\x32\x11.gqldb.TypedValue\"(\n\x03Row\x12!\n\x06values\x18\x01 \x03(\x0b\x32\x11.gqldb.TypedValue\"\x8e\x01\n\x08\x44mlStats\x12\x16\n\x0einserted_nodes\x18\x01 \x01(\x03\x12\x16\n\x0einserted_edges\x18\x02 \x01(\x03\x12\x15\n\rdeleted_nodes\x18\x03 \x01(\x03\x12\x15\n\rdeleted_edges\x18\x04 \x01(\x03\x12\x11\n\tset_nodes\x18\x05 \x01(\x03\x12\x11\n\tset_edges\x18\x06 \x01(\x03\"I\n\x0cLoginRequest\x12\x10\n\x08username\x18\x01 \x01(\t\x12\x10\n\x08password\x18\x02 \x01(\t\x12\x15\n\rdefault_graph\x18\x03 \x01(\t\"\xfd\x01\n\rLoginResponse\x12\x12\n\nsession_id\x18\x01 \x01(\x04\x12\x16\n\x0eserver_version\x18\x02 \x01(\t\x12\r\n\x05roles\x18\x03 \x03(\t\x12\x12\n\nis_cluster\x18\n \x01(\x08\x12\x12\n\ncluster_id\x18\x0b \x01(\t\x12\x17\n\x0fpartition_count\x18\x0c \x01(\x05\x12\x14\n\x0c\x63\x61pabilities\x18\x14 \x03(\t\x12\x15\n\rcurrent_graph\x18\x15 \x01(\t\x12\x14\n\x0ctime_cost_ns\x18\x16 \x01(\x03\x12\x14\n\x0c\x64isk_cost_ns\x18\x17 \x01(\x03\x12\x17\n\x0f\x63ompute_cost_ns\x18\x18 \x01(\x03\"\xbd\x01\n\nGqlRequest\x12\x0b\n\x03gql\x18\x01 \x01(\t\x12\x12\n\ngraph_name\x18\x02 \x01(\t\x12$\n\nparameters\x18\x03 \x03(\x0b\x32\x10.gqldb.Parameter\x12\x12\n\nsession_id\x18\x04 \x01(\x04\x12\x16\n\x0etransaction_id\x18\x05 \x01(\x04\x12\x0f\n\x07timeout\x18\x06 \x01(\x05\x12\x11\n\tread_only\x18\x07 \x01(\x08\x12\x18\n\x10max_path_results\x18\x08 \x01(\x03\"\x86\x02\n\x0bGqlResponse\x12\x0f\n\x07\x63olumns\x18\x01 \x03(\t\x12\x18\n\x04rows\x18\x02 \x03(\x0b\x32\n.gqldb.Row\x12\x11\n\trow_count\x18\x03 \x01(\x03\x12\x10\n\x08has_more\x18\x04 \x01(\x08\x12\x10\n\x08warnings\x18\x05 \x03(\t\x12\x15\n\rrows_affected\x18\x06 \x01(\x03\x12\x15\n\rcurrent_graph\x18\x07 \x01(\t\x12\x14\n\x0ctime_cost_ns\x18\x08 \x01(\x03\x12\x14\n\x0c\x64isk_cost_ns\x18\t \x01(\x03\x12\x17\n\x0f\x63ompute_cost_ns\x18\n \x01(\x03\x12\"\n\tdml_stats\x18\x0b \x01(\x0b\x32\x0f.gqldb.DmlStats*\x90\x07\n\x0cPropertyType\x12\x17\n\x13PROPERTY_TYPE_UNSET\x10\x00\x12\x17\n\x13PROPERTY_TYPE_INT32\x10\x01\x12\x18\n\x14PROPERTY_TYPE_UINT32\x10\x02\x12\x17\n\x13PROPERTY_TYPE_INT64\x10\x03\x12\x18\n\x14PROPERTY_TYPE_UINT64\x10\x04\x12\x17\n\x13PROPERTY_TYPE_FLOAT\x10\x05\x12\x18\n\x14PROPERTY_TYPE_DOUBLE\x10\x06\x12\x18\n\x14PROPERTY_TYPE_STRING\x10\x07\x12\x1a\n\x16PROPERTY_TYPE_DATETIME\x10\x08\x12\x1b\n\x17PROPERTY_TYPE_TIMESTAMP\x10\t\x12\x16\n\x12PROPERTY_TYPE_TEXT\x10\n\x12\x16\n\x12PROPERTY_TYPE_BLOB\x10\x0b\x12\x17\n\x13PROPERTY_TYPE_POINT\x10\x0c\x12\x19\n\x15PROPERTY_TYPE_DECIMAL\x10\r\x12\x16\n\x12PROPERTY_TYPE_LIST\x10\x0e\x12\x15\n\x11PROPERTY_TYPE_SET\x10\x0f\x12\x15\n\x11PROPERTY_TYPE_MAP\x10\x10\x12\x16\n\x12PROPERTY_TYPE_NULL\x10\x11\x12\x16\n\x12PROPERTY_TYPE_BOOL\x10\x12\x12 \n\x1cPROPERTY_TYPE_LOCAL_DATETIME\x10\x13\x12 \n\x1cPROPERTY_TYPE_ZONED_DATETIME\x10\x14\x12\x16\n\x12PROPERTY_TYPE_DATE\x10\x15\x12\x1c\n\x18PROPERTY_TYPE_ZONED_TIME\x10\x16\x12\x1c\n\x18PROPERTY_TYPE_LOCAL_TIME\x10\x17\x12\x1f\n\x1bPROPERTY_TYPE_YEAR_TO_MONTH\x10\x18\x12\x1f\n\x1bPROPERTY_TYPE_DAY_TO_SECOND\x10\x19\x12\x18\n\x14PROPERTY_TYPE_RECORD\x10\x1a\x12\x19\n\x15PROPERTY_TYPE_POINT3D\x10\x1b\x12\x18\n\x14PROPERTY_TYPE_VECTOR\x10\x1c\x12\x17\n\x13PROPERTY_TYPE_TABLE\x10\x1d\x12\x16\n\x12PROPERTY_TYPE_PATH\x10\x1e\x12\x17\n\x13PROPERTY_TYPE_ERROR\x10\x1f\x12\x16\n\x12PROPERTY_TYPE_NODE\x10 \x12\x16\n\x12PROPERTY_TYPE_EDGE\x10!2D\n\x0eSessionService\x12\x32\n\x05Login\x12\x13.gqldb.LoginRequest\x1a\x14.gqldb.LoginResponse2<\n\x0cQueryService\x12,\n\x03Gql\x12\x11.gqldb.GqlRequest\x1a\x12.gqldb.GqlResponseb\x06proto3"
-
-pool = ::Google::Protobuf::DescriptorPool.generated_pool
-pool.add_serialized_file(descriptor_data)
-
-module Gqldb
-  TypedValue = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.TypedValue").msgclass
-  Parameter = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.Parameter").msgclass
-  Row = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.Row").msgclass
-  DmlStats = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.DmlStats").msgclass
-  LoginRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.LoginRequest").msgclass
-  LoginResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.LoginResponse").msgclass
-  GqlRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.GqlRequest").msgclass
-  GqlResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.GqlResponse").msgclass
-  PropertyType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("gqldb.PropertyType").enummodule
-end

data/lib/tina4_ultipa/gen/gqldb_services_pb.rb

@@ -1,36 +0,0 @@
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# Source: gqldb.proto for package 'gqldb'
-
-require 'grpc'
-require 'gqldb_pb'
-
-module Gqldb
-  module SessionService
-    class Service
-
-      include ::GRPC::GenericService
-
-      self.marshal_class_method = :encode
-      self.unmarshal_class_method = :decode
-      self.service_name = 'gqldb.SessionService'
-
-      rpc :Login, ::Gqldb::LoginRequest, ::Gqldb::LoginResponse
-    end
-
-    Stub = Service.rpc_stub_class
-  end
-  module QueryService
-    class Service
-
-      include ::GRPC::GenericService
-
-      self.marshal_class_method = :encode
-      self.unmarshal_class_method = :decode
-      self.service_name = 'gqldb.QueryService'
-
-      rpc :Gql, ::Gqldb::GqlRequest, ::Gqldb::GqlResponse
-    end
-
-    Stub = Service.rpc_stub_class
-  end
-end