t-tech-investments 0.1.0 → 0.1.1

data/lib/t/tech/investments/proto_loader.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module T
+  module Tech
+    module Investments
+      # Loads generated proto files so that Service/Stub classes and messages are available.
+      # Adds proto directory to $LOAD_PATH and requires contract files in dependency order.
+      module ProtoLoader
+        PROTO_DIR = File.expand_path("proto", __dir__)
+
+        # Contract _pb.rb (messages); order respects dependencies.
+        PB_FILES = %w[
+          common_pb
+          instruments_pb
+          marketdata_pb
+          operations_pb
+          orders_pb
+          sandbox_pb
+          signals_pb
+          stoporders_pb
+          users_pb
+        ].freeze
+
+        # Service definitions (depend on _pb).
+        SERVICES_FILES = %w[
+          users_services_pb
+          instruments_services_pb
+          marketdata_services_pb
+          operations_services_pb
+          orders_services_pb
+          sandbox_services_pb
+          signals_services_pb
+          stoporders_services_pb
+        ].freeze
+
+        module_function
+
+        def load!
+          return if @loaded
+
+          $LOAD_PATH.unshift(PROTO_DIR) unless $LOAD_PATH.include?(PROTO_DIR)
+          PB_FILES.each { |f| require f }
+          SERVICES_FILES.each { |f| require f }
+          @loaded = true
+        end
+      end
+    end
+  end
+end

data/lib/t/tech/investments/services/market_data_facade.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module T
+  module Tech
+    module Investments
+      module Services
+        # Combines unary MarketData RPCs and #stream for MarketDataStream bidi.
+        # client.market_data.get_candles(...) -> unary; client.market_data.stream { |s| ... } -> stream session.
+        class MarketDataFacade
+          def initialize(unary_adapter, transport)
+            @unary_adapter = unary_adapter
+            @transport = transport
+          end
+
+          def stream(timeout: nil, &block)
+            session = MarketDataStreamSession.new(@transport, timeout: timeout)
+            block&.call(session)
+          end
+
+          def method_missing(method_name, *args, **kwargs, &block)
+            if @unary_adapter.respond_to?(method_name)
+              @unary_adapter.public_send(method_name, *args, **kwargs, &block)
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            @unary_adapter.respond_to?(method_name, include_private) || super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/t/tech/investments/services/market_data_stream_session.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module T
+  module Tech
+    module Investments
+      module Services
+        # Session for MarketDataStream bidi: queue of outgoing requests, each_event yields
+        # Ruby-friendly events (ping ignored). Uses Coercers for request building and response mapping.
+        # Reconciliation: call get_my_subscriptions then resubscribe or restart stream as needed.
+        # Contract (Tinkoff::...) is resolved at runtime after ProtoLoader.load!
+        # rubocop:disable Metrics/ClassLength
+        class MarketDataStreamSession
+          CONTRACT_NS = "Tinkoff::Public::Invest::Api::Contract::V1"
+
+          REQUEST_SPECS = {
+            subscribe_candles: %i[SubscribeCandlesRequest subscribe_candles_request],
+            subscribe_order_book: %i[SubscribeOrderBookRequest subscribe_order_book_request],
+            subscribe_trades: %i[SubscribeTradesRequest subscribe_trades_request],
+            subscribe_info: %i[SubscribeInfoRequest subscribe_info_request],
+            subscribe_last_price: %i[SubscribeLastPriceRequest subscribe_last_price_request],
+            get_my_subscriptions: %i[GetMySubscriptions get_my_subscriptions]
+          }.freeze
+
+          # Response payload field name -> event type (we skip :ping)
+          RESPONSE_PAYLOAD_TO_TYPE = {
+            subscribe_candles_response: :subscribe_candles_response,
+            subscribe_order_book_response: :subscribe_order_book_response,
+            subscribe_trades_response: :subscribe_trades_response,
+            subscribe_info_response: :subscribe_info_response,
+            candle: :candle,
+            trade: :trade,
+            orderbook: :orderbook,
+            trading_status: :trading_status,
+            ping: :ping,
+            subscribe_last_price_response: :subscribe_last_price_response,
+            last_price: :last_price,
+            open_interest: :open_interest
+          }.freeze
+
+          def initialize(transport, timeout: nil)
+            @transport = transport
+            @timeout = timeout
+            @queue = Queue.new
+          end
+
+          def subscribe_candles(**kwargs)
+            push_request(:subscribe_candles, kwargs)
+          end
+
+          def subscribe_order_book(**kwargs)
+            push_request(:subscribe_order_book, kwargs)
+          end
+
+          def subscribe_trades(**kwargs)
+            push_request(:subscribe_trades, kwargs)
+          end
+
+          def subscribe_info(**kwargs)
+            push_request(:subscribe_info, kwargs)
+          end
+
+          def subscribe_last_price(**kwargs)
+            push_request(:subscribe_last_price, kwargs)
+          end
+
+          def get_my_subscriptions # rubocop:disable Naming/AccessorMethodName
+            push_request(:get_my_subscriptions, {})
+          end
+
+          # Iterates server responses as events (Hash with :type and :data). Ignores ping.
+          # rubocop:disable Metrics/MethodLength
+          # Request stream is fed from the queue (subscribe_* / get_my_subscriptions pushed earlier).
+          def each_event(&block)
+            return to_enum(:each_event) unless block
+
+            request_enum = build_request_enum
+            stream_stub = @transport.stub(contract::MarketDataStreamService::Stub)
+            response_enum = @transport.bidi_stream(
+              stream_stub, :market_data_stream, request_enum, timeout: @timeout
+            )
+            response_enum.each do |response|
+              event = response_to_event(response)
+              next if event.nil?
+
+              block.call(event)
+            end
+          end
+          # rubocop:enable Metrics/MethodLength
+
+          private
+
+          def contract
+            @contract ||= Object.const_get(CONTRACT_NS)
+          end
+
+          def push_request(kind, kwargs)
+            msg_name, oneof_key = REQUEST_SPECS.fetch(kind)
+            msg_class = contract.const_get(msg_name)
+            inner = kwargs.empty? ? msg_class.new : Coercers.to_request(msg_class, kwargs)
+            req = contract::MarketDataRequest.new(oneof_key => inner)
+            @queue.push(req)
+          end
+
+          def build_request_enum
+            Enumerator.new do |y|
+              loop { y.yield @queue.pop }
+            end
+          end
+
+          def response_to_event(response)
+            payload_type, payload = extract_payload(response)
+            return nil if payload_type.nil? || payload_type == :ping
+
+            event_type = RESPONSE_PAYLOAD_TO_TYPE[payload_type]
+            data = payload ? Coercers.to_hash(payload, ruby_friendly: true) : {}
+            { type: event_type, data: data }
+          end
+
+          # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def extract_payload(response)
+            if response.respond_to?(:which_oneof)
+              field = response.which_oneof("payload")
+              if field
+                field_sym = field.to_sym
+                val = response.public_send(field_sym)
+                return [field_sym, val] if val
+              end
+            end
+            RESPONSE_PAYLOAD_TO_TYPE.each_key do |f|
+              next unless response.respond_to?(f)
+
+              val = response.public_send(f)
+              next if val.nil?
+              return [f, val] if protobuf_message?(val) || val.to_s.to_s.strip != ""
+            end
+            [nil, nil]
+          end
+          # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          def protobuf_message?(val)
+            val.respond_to?(:descriptor) && val.respond_to?(:to_h)
+          end
+        end
+        # rubocop:enable Metrics/ClassLength
+      end
+    end
+  end
+end

data/lib/t/tech/investments/services/registry.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module T
+  module Tech
+    module Investments
+      module Services
+        # Maps SDK service names to gRPC Service classes. Used by Client to build adapters.
+        # Resolves constants after proto is loaded (no Tinkoff at require time).
+        module Registry
+          CONTRACT_NS = "Tinkoff::Public::Invest::Api::Contract::V1"
+
+          SERVICE_CLASS_PATHS = {
+            users: "#{CONTRACT_NS}::UsersService::Service",
+            instruments: "#{CONTRACT_NS}::InstrumentsService::Service",
+            market_data: "#{CONTRACT_NS}::MarketDataService::Service",
+            market_data_stream: "#{CONTRACT_NS}::MarketDataStreamService::Service",
+            operations: "#{CONTRACT_NS}::OperationsService::Service",
+            orders: "#{CONTRACT_NS}::OrdersService::Service",
+            sandbox: "#{CONTRACT_NS}::SandboxService::Service",
+            stop_orders: "#{CONTRACT_NS}::StopOrdersService::Service",
+            signals: "#{CONTRACT_NS}::SignalService::Service"
+          }.freeze
+
+          module_function
+
+          def service_class(name)
+            path = SERVICE_CLASS_PATHS.fetch(name) { raise KeyError, "Unknown service: #{name.inspect}" }
+            Object.const_get(path)
+          end
+
+          def service_names
+            SERVICE_CLASS_PATHS.keys
+          end
+        end
+      end
+    end
+  end
+end

data/lib/t/tech/investments/services/unary_adapter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module T
+  module Tech
+    module Investments
+      module Services
+        # Adapter that exposes unary RPCs from a gRPC Service class via Transport + Coercers.
+        # Methods are defined dynamically from service_class.rpc_descs (no streaming in this adapter).
+        class UnaryAdapter
+          attr_reader :service_class, :transport, :stub
+
+          def initialize(service_class, transport)
+            @service_class = service_class
+            @transport = transport
+            @stub = transport.stub(service_class.rpc_stub_class)
+            define_unary_methods!
+          end
+
+          private
+
+          def define_unary_methods!
+            service_class.rpc_descs.each_value do |desc|
+              next unless unary?(desc)
+
+              method_sym = rpc_name_to_snake(desc.name)
+              request_class = desc.input
+              response_class = desc.output
+              define_unary_method(method_sym, request_class, response_class)
+            end
+          end
+
+          def unary?(desc)
+            !stream_type?(desc.input) && !stream_type?(desc.output)
+          end
+
+          def stream_type?(val)
+            val.is_a?(::GRPC::RpcDesc::Stream)
+          end
+
+          def rpc_name_to_snake(name)
+            name.to_s
+                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                .downcase
+                .to_sym
+          end
+
+          def define_unary_method(method_sym, request_class, _response_class)
+            return if singleton_class.method_defined?(method_sym)
+
+            adapter = self
+            define_singleton_method(method_sym) do |**kwargs, &_block|
+              raw = kwargs.delete(:raw)
+              timeout = kwargs.delete(:timeout)
+              request = Coercers.to_request(request_class, kwargs)
+              response = adapter.transport.unary(adapter.stub, method_sym, request, timeout: timeout)
+              raw ? response : Coercers.to_hash(response, ruby_friendly: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/t/tech/investments/services.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "services/unary_adapter"
+require_relative "services/registry"
+require_relative "services/market_data_stream_session"
+require_relative "services/market_data_facade"

data/lib/t/tech/investments/transport.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "grpc"
+
+module T
+  module Tech
+    module Investments
+      # gRPC transport: channel, metadata, deadlines, unary calls, error mapping.
+      # No business logic; Services call Transport, not stubs directly.
+      class Transport
+        TRACKING_ID_KEY = "x-tracking-id"
+
+        attr_reader :config
+
+        def initialize(config_snapshot)
+          @config = config_snapshot
+          @channel = nil
+          @stubs = {}
+        end
+
+        # Returns a stub for the given stub class (e.g. UsersService::Stub).
+        # Stubs are cached per class. Channel uses TLS for default endpoint.
+        def stub(stub_class)
+          @stubs[stub_class] ||= stub_class.new(
+            config.endpoint,
+            channel_credentials,
+            channel_args: {}
+          )
+        end
+
+        # Performs a unary RPC: request metadata, deadline, call stub, map GRPC::BadStatus → Errors::GrpcError.
+        # @param stub_instance [Object] gRPC stub (from #stub)
+        # @param method_name [Symbol] e.g. :get_accounts
+        # @param request [Object] protobuf request message
+        # @param timeout [Integer, nil] optional override in seconds
+        # @return [Object] protobuf response message
+        def unary(stub_instance, method_name, request, timeout: nil)
+          opts = request_options(timeout)
+          stub_instance.public_send(method_name, request, opts)
+        rescue GRPC::BadStatus => e
+          raise map_bad_status(e)
+        end
+
+        # Bidirectional stream: sends request_enum, returns response Enumerator.
+        # Maps GRPC::BadStatus when iterating responses; extracts x-tracking-id from metadata.
+        # @param stub_instance [Object] gRPC stub (from #stub)
+        # @param method_name [Symbol] e.g. :market_data_stream
+        # @param request_enum [Enumerator] yields protobuf request messages
+        # @param timeout [Integer, nil] optional override in seconds
+        # @return [Enumerator] yields protobuf response messages; raises Errors::GrpcError on stream error
+        def bidi_stream(stub_instance, method_name, request_enum, timeout: nil)
+          opts = request_options(timeout)
+          response_enum = stub_instance.public_send(method_name, request_enum, opts)
+          wrap_response_enum(response_enum)
+        end
+
+        def close
+          @channel&.close
+          @channel = nil
+          @stubs.clear
+        end
+
+        private
+
+        def channel_credentials
+          return @channel_credentials if defined?(@channel_credentials) && @channel_credentials
+
+          certs_path = config.ssl_ca_certs.to_s.strip
+          if certs_path.empty?
+            @channel_credentials = GRPC::Core::ChannelCredentials.new
+            return @channel_credentials
+          end
+
+          pem = read_ssl_ca_certs(certs_path)
+          @channel_credentials = GRPC::Core::ChannelCredentials.new(pem)
+        end
+
+        def read_ssl_ca_certs(path)
+          pem = File.read(path)
+          if pem.to_s.strip.empty?
+            raise Errors::ConfigurationError, "SSL CA certs file is empty: #{path}"
+          end
+          pem
+        rescue Errno::ENOENT, Errno::EACCES => e
+          raise Errors::ConfigurationError, "SSL CA certs file is not readable: #{path} (#{e.class})"
+        end
+
+        def request_options(timeout)
+          deadline = Time.now + (timeout || config.timeout)
+          {
+            metadata: request_metadata,
+            deadline: deadline
+          }
+        end
+
+        def request_metadata
+          meta = { "authorization" => "Bearer #{config.token}" }
+          meta["x-app-name"] = config.app_name unless config.app_name.to_s.empty?
+          meta
+        end
+
+        def map_bad_status(err)
+          tracking_id = extract_tracking_id(err)
+          Errors::GrpcError.new(
+            err.message.to_s,
+            code: err.code,
+            details: err.details.to_s,
+            tracking_id: tracking_id
+          )
+        end
+
+        def extract_tracking_id(bad_status)
+          return nil unless bad_status.respond_to?(:metadata) && bad_status.metadata
+
+          meta = normalized_metadata_hash(bad_status.metadata)
+          return nil unless meta.is_a?(Hash)
+
+          meta[TRACKING_ID_KEY] || meta[TRACKING_ID_KEY.tr("-", "_")] || meta[:x_tracking_id]
+        end
+
+        def normalized_metadata_hash(raw)
+          return nil unless raw.is_a?(Hash)
+
+          raw.key?(:metadata) ? raw[:metadata] : raw
+        end
+
+        def wrap_response_enum(response_enum)
+          Enumerator.new do |y|
+            response_enum.each { |msg| y.yield msg }
+          rescue GRPC::BadStatus => e
+            raise map_bad_status(e)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/t/tech/investments/version.rb

@@ -3,7 +3,7 @@
 module T
   module Tech
     module Investments
-      VERSION = "0.1.0"
+      VERSION = "0.1.1"
     end
   end
 end

data/lib/t/tech/investments.rb

@@ -6,7 +6,36 @@ module T
   module Tech
     module Investments
       class Error < StandardError; end
-      # Your code goes here...
+    end
+  end
+end
+
+require_relative "investments/errors"
+require_relative "investments/configuration"
+require_relative "investments/transport"
+require_relative "investments/coercers"
+require_relative "investments/proto_loader"
+require_relative "investments/services"
+require_relative "investments/client"
+
+module T
+  module Tech
+    module Investments
+      class << self
+        attr_accessor :configuration
+      end
+
+      self.configuration = Configuration.from_env
+
+      def self.configure
+        yield configuration if block_given?
+        configuration
+      end
+
+      def self.client(overrides = {})
+        config = configuration.merge(overrides)
+        Client.new(config.snapshot)
+      end
     end
   end
 end

data/script/regenerate_proto

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Regenerates Ruby protobuf and gRPC code from invest-contracts.
+# Reads contracts.lock for repository and ref, then runs grpc_tools_ruby_protoc.
+# Run from project root: bundle exec ruby script/regenerate_proto
+# rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+
+require "english"
+require "json"
+require "fileutils"
+require "open3"
+
+PROJECT_ROOT = File.expand_path("..", __dir__)
+CONTRACTS_LOCK = File.join(PROJECT_ROOT, "contracts.lock")
+OUTPUT_DIR = File.join(PROJECT_ROOT, "lib", "t", "tech", "investments", "proto")
+TMP_REPO = File.join(PROJECT_ROOT, "tmp", "investAPI")
+
+def load_lock
+  data = JSON.parse(File.read(CONTRACTS_LOCK))
+  [data["repository"], data["ref"], File.join(data["contracts_path"] || "src/docs/contracts", "")]
+end
+
+def clone_or_fetch(repo_url, ref)
+  FileUtils.mkdir_p(File.dirname(TMP_REPO))
+  if Dir.exist?(TMP_REPO)
+    system("git", "-C", TMP_REPO, "fetch", "origin", "tag", ref, "--no-tags", out: File::NULL, err: File::NULL) ||
+      system("git", "-C", TMP_REPO, "fetch", "origin", ref, out: File::NULL, err: File::NULL)
+  else
+    system("git", "clone", "--depth", "1", "--no-single-branch", repo_url, TMP_REPO,
+           out: File::NULL, err: File::NULL) ||
+      system("git", "clone", repo_url, TMP_REPO, out: File::NULL, err: File::NULL)
+    return false unless $CHILD_STATUS.success?
+
+    system("git", "-C", TMP_REPO, "fetch", "origin", ref,
+           out: File::NULL, err: File::NULL)
+  end
+  system("git", "-C", TMP_REPO, "checkout", ref, out: File::NULL, err: File::NULL)
+end
+
+def proto_include_path
+  grpc_tools = Gem::Specification.find_by_name("grpc-tools")
+  base = grpc_tools.full_gem_path
+  %w[include src].each do |sub|
+    path = File.join(base, sub)
+    ts = File.join(path, "google", "protobuf", "timestamp.proto")
+    return path if File.file?(ts)
+  end
+  nil
+rescue Gem::MissingSpecError
+  nil
+end
+
+def run_protoc(contracts_dir, extra_include)
+  FileUtils.rm_rf(OUTPUT_DIR)
+  FileUtils.mkdir_p(OUTPUT_DIR)
+
+  proto_files = Dir[File.join(contracts_dir, "**", "*.proto")].sort
+  proto_files.reject! { |f| f.include?("google/protobuf/") } # skip if any vendored
+  if proto_files.empty?
+    # Flat list in contracts_path only
+    contracts_path = File.dirname(contracts_dir.chomp("/"))
+    proto_files = Dir[File.join(contracts_path, "*.proto")].sort
+    proto_files += Dir[File.join(contracts_path, "google", "api", "*.proto")].sort
+    contracts_dir = contracts_path
+  end
+
+  args = ["-I", contracts_dir]
+  args += ["-I", extra_include] if extra_include
+  args += ["--ruby_out", OUTPUT_DIR, "--grpc_out", OUTPUT_DIR]
+  args += proto_files
+
+  stdout, stderr, status = Open3.capture3("bundle", "exec", "grpc_tools_ruby_protoc", *args, chdir: PROJECT_ROOT)
+  unless status.success?
+    warn stderr
+    warn stdout
+    return false
+  end
+  true
+end
+
+def main
+  Dir.chdir(PROJECT_ROOT)
+
+  unless File.file?(CONTRACTS_LOCK)
+    warn "contracts.lock not found at #{CONTRACTS_LOCK}"
+    exit 1
+  end
+
+  repo_url, ref, contracts_subpath = load_lock
+  contracts_dir = File.join(TMP_REPO, contracts_subpath.to_s.chomp("/"))
+  contracts_dir = File.join(TMP_REPO, "src/docs/contracts") unless Dir.exist?(contracts_dir)
+
+  puts "Repository: #{repo_url} @ #{ref}"
+  puts "Contracts:  #{contracts_dir}"
+
+  unless clone_or_fetch(repo_url, ref)
+    warn "Failed to clone/fetch repository"
+    exit 1
+  end
+
+  unless Dir.exist?(contracts_dir)
+    warn "Contracts directory not found: #{contracts_dir}"
+    exit 1
+  end
+
+  extra_include = proto_include_path
+  puts "Output:     #{OUTPUT_DIR}"
+
+  unless run_protoc(contracts_dir, extra_include)
+    warn "protoc failed"
+    exit 1
+  end
+
+  puts "Done. Generated files in #{OUTPUT_DIR}"
+end
+# rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+main