squirreldb-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a43ce4beedd5703705fb80885a05a914a7b46466cf6a2503629bbe2f6c49ade7
+  data.tar.gz: cab0bcc0c3e779169a5ec73c60ad5ba32b3d957c5a566205303ed768563b5915
+SHA512:
+  metadata.gz: d7152d7f43378e2abffcbf77b1309abd276e13a37759dc70e48bd19ded705ad32de31fdf2b17e6673360d9ce1709d7e408bbdc34f5656e09116e9d135b55f3d3
+  data.tar.gz: 0b36d4f5f4e8a1f6141113eb768264ccd2c4c7079d448892f8cb497e10b3f164ff5456ea418d72cf0b3cba343a86985489a975c87a9b97ab645dbf344f1b87fc

data/lib/squirreldb/cache.rb

@@ -0,0 +1,163 @@
+# SquirrelDB Ruby SDK - Cache (Redis-compatible)
+# Generated by sdk-generator v0.1.0
+# DO NOT EDIT MANUALLY
+
+# frozen_string_literal: true
+
+require "socket"
+
+module SquirrelDB
+  # Redis-compatible cache client using RESP protocol
+  class Cache
+    class Error < StandardError; end
+
+    def initialize(host: "localhost", port: 6379)
+      @host = host
+      @port = port
+      @socket = nil
+    end
+
+    def self.connect(host: "localhost", port: 6379)
+      cache = new(host: host, port: port)
+      cache.send(:do_connect)
+      cache
+    end
+
+    def get(key)
+      resp = command("GET", key)
+      resp.is_a?(NilClass) ? nil : resp
+    end
+
+    def set(key, value, ttl: nil)
+      if ttl
+        command("SET", key, value, "EX", ttl.to_s)
+      else
+        command("SET", key, value)
+      end
+      true
+    end
+
+    def del(key)
+      command("DEL", key) > 0
+    end
+
+    def exists(key)
+      command("EXISTS", key) > 0
+    end
+
+    def expire(key, seconds)
+      command("EXPIRE", key, seconds.to_s) > 0
+    end
+
+    def ttl(key)
+      command("TTL", key)
+    end
+
+    def incr(key)
+      command("INCR", key)
+    end
+
+    def decr(key)
+      command("DECR", key)
+    end
+
+    def incrby(key, amount)
+      command("INCRBY", key, amount.to_s)
+    end
+
+    def decrby(key, amount)
+      command("DECRBY", key, amount.to_s)
+    end
+
+    def mget(*keys)
+      command("MGET", *keys)
+    end
+
+    def mset(hash)
+      args = hash.flat_map { |k, v| [k.to_s, v.to_s] }
+      command("MSET", *args)
+      true
+    end
+
+    def keys(pattern = "*")
+      command("KEYS", pattern)
+    end
+
+    def dbsize
+      command("DBSIZE")
+    end
+
+    def flushdb
+      command("FLUSHDB")
+      true
+    end
+
+    def info
+      result = command("INFO")
+      result.split("\n").reject { |l| l.empty? || l.start_with?("#") }.map do |line|
+        line.split(":", 2)
+      end.to_h
+    end
+
+    def ping
+      command("PING") == "PONG"
+    end
+
+    def close
+      command("QUIT") rescue nil
+      @socket&.close
+      @socket = nil
+    end
+
+    private
+
+    def do_connect
+      @socket = TCPSocket.new(@host, @port)
+    end
+
+    def command(*args)
+      raise Error, "Not connected" unless @socket
+
+      @socket.write(encode_command(args))
+      read_response
+    end
+
+    def encode_command(args)
+      parts = ["*#{args.length}\r\n"]
+      args.each do |arg|
+        arg = arg.to_s
+        parts << "$#{arg.bytesize}\r\n#{arg}\r\n"
+      end
+      parts.join
+    end
+
+    def read_response
+      line = @socket.gets.chomp
+      prefix = line[0]
+      content = line[1..]
+
+      case prefix
+      when "+"
+        content
+      when "-"
+        raise Error, content
+      when ":"
+        content.to_i
+      when "$"
+        len = content.to_i
+        return nil if len == -1
+
+        data = @socket.read(len)
+        @socket.read(2) # Read \r\n
+        data
+      when "*"
+        count = content.to_i
+        return nil if count == -1
+
+        count.times.map { read_response }
+      else
+        raise Error, "Unknown RESP type: #{prefix}"
+      end
+    end
+  end
+end

data/lib/squirreldb/client.rb

@@ -0,0 +1,202 @@
+# SquirrelDB Ruby SDK - Client
+# Generated by sdk-generator v0.1.0
+# DO NOT EDIT MANUALLY
+
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "websocket-client-simple"
+require "thread"
+
+module SquirrelDB
+  # Client for connecting to SquirrelDB
+  class Client
+    def initialize(url, reconnect: true, max_reconnect_attempts: 10, reconnect_delay: 1.0)
+      @url = url.start_with?("ws://", "wss://") ? url : "ws://#{url}"
+      @reconnect = reconnect
+      @max_reconnect_attempts = max_reconnect_attempts
+      @reconnect_delay = reconnect_delay
+      @pending = {}
+      @subscriptions = {}
+      @mutex = Mutex.new
+      @closed = false
+      @reconnect_attempts = 0
+    end
+
+    def self.connect(url, **options)
+      client = new(url, **options)
+      client.send(:do_connect)
+      client
+    end
+
+    def query(q)
+      resp = send_message({ type: "query", id: generate_id, query: q })
+      raise resp["error"] if resp["type"] == "error"
+      resp["data"].map { |d| Document.from_hash(d) }
+    end
+
+    def subscribe(table_name)
+      SubscriptionBuilder.new(self, table_name)
+    end
+
+    def subscribe_raw(q, &callback)
+      sub_id = generate_id
+      resp = send_message({ type: "subscribe", id: sub_id, query: q })
+      raise resp["error"] if resp["type"] == "error"
+      @mutex.synchronize { @subscriptions[sub_id] = callback }
+      sub_id
+    end
+
+    def unsubscribe(subscription_id)
+      send_message({ type: "unsubscribe", id: subscription_id })
+      @mutex.synchronize { @subscriptions.delete(subscription_id) }
+      nil
+    end
+
+    def insert(collection, data)
+      resp = send_message({
+        type: "insert",
+        id: generate_id,
+        collection: collection,
+        data: data
+      })
+      raise resp["error"] if resp["type"] == "error"
+      Document.from_hash(resp["data"])
+    end
+
+    def update(collection, document_id, data)
+      resp = send_message({
+        type: "update",
+        id: generate_id,
+        collection: collection,
+        document_id: document_id,
+        data: data
+      })
+      raise resp["error"] if resp["type"] == "error"
+      Document.from_hash(resp["data"])
+    end
+
+    def delete(collection, document_id)
+      resp = send_message({
+        type: "delete",
+        id: generate_id,
+        collection: collection,
+        document_id: document_id
+      })
+      raise resp["error"] if resp["type"] == "error"
+      Document.from_hash(resp["data"])
+    end
+
+    def list_collections
+      resp = send_message({ type: "listcollections", id: generate_id })
+      raise resp["error"] if resp["type"] == "error"
+      resp["data"]
+    end
+
+    def ping
+      resp = send_message({ type: "ping", id: generate_id })
+      raise "Unexpected response" unless resp["type"] == "pong"
+      nil
+    end
+
+    def close
+      @closed = true
+      @mutex.synchronize { @subscriptions.clear }
+      @ws&.close
+    end
+
+    private
+
+    def do_connect
+      @ws = WebSocket::Client::Simple.connect(@url)
+      client = self
+
+      @ws.on :message do |msg|
+        client.send(:handle_message, msg.data)
+      end
+
+      @ws.on :close do
+        client.send(:handle_disconnect)
+      end
+
+      @ws.on :error do |e|
+        # Handle error silently
+      end
+
+      sleep 0.1 until @ws.open?
+      @reconnect_attempts = 0
+    end
+
+    def handle_message(data)
+      msg = JSON.parse(data)
+      msg_type = msg["type"]
+      msg_id = msg["id"]
+
+      if msg_type == "change"
+        callback = @mutex.synchronize { @subscriptions[msg_id] }
+        callback&.call(ChangeEvent.from_hash(msg["change"]))
+        return
+      end
+
+      queue = @mutex.synchronize { @pending.delete(msg_id) }
+      queue&.push(msg)
+    rescue JSON::ParserError
+      # Ignore malformed messages
+    end
+
+    def handle_disconnect
+      return if @closed
+
+      @mutex.synchronize do
+        @pending.each_value { |q| q.push({ "type" => "error", "error" => "Connection closed" }) }
+        @pending.clear
+      end
+
+      if @reconnect && @reconnect_attempts < @max_reconnect_attempts
+        @reconnect_attempts += 1
+        delay = @reconnect_delay * (2 ** (@reconnect_attempts - 1))
+        sleep delay
+        do_connect rescue nil
+      end
+    end
+
+    def send_message(msg)
+      raise "Not connected" unless @ws&.open?
+
+      queue = Queue.new
+      @mutex.synchronize { @pending[msg[:id]] = queue }
+
+      @ws.send(msg.to_json)
+      queue.pop
+    end
+
+    def generate_id
+      SecureRandom.uuid
+    end
+  end
+
+  # Subscription builder for fluent change subscriptions
+  class SubscriptionBuilder
+    def initialize(client, table_name)
+      @client = client
+      @table_name = table_name
+      @filter_condition = nil
+    end
+
+    def find(condition = nil, &block)
+      @filter_condition = block_given? ? block.call(Query::DocProxy.new) : condition
+      self
+    end
+
+    def changes(&callback)
+      query = { "table" => @table_name, "changes" => { "includeInitial" => false } }
+      query["filter"] = Query.filter_to_structured(@filter_condition) if @filter_condition
+      @client.subscribe_structured(query, &callback)
+    end
+  end
+
+  def self.connect(url, **options)
+    Client.connect(url, **options)
+  end
+end

data/lib/squirreldb/storage.rb

@@ -0,0 +1,177 @@
+# SquirrelDB Ruby SDK - Storage (S3-compatible)
+# Generated by sdk-generator v0.1.0
+# DO NOT EDIT MANUALLY
+
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "openssl"
+require "time"
+require "rexml/document"
+
+module SquirrelDB
+  # S3-compatible storage client
+  class Storage
+    class Error < StandardError
+      attr_reader :status_code
+
+      def initialize(message, status_code = nil)
+        super(message)
+        @status_code = status_code
+      end
+    end
+
+    Bucket = Struct.new(:name, :created_at, keyword_init: true)
+    StorageObject = Struct.new(:key, :size, :etag, :last_modified, keyword_init: true)
+
+    def initialize(endpoint:, access_key: nil, secret_key: nil, region: "us-east-1")
+      @endpoint = endpoint.chomp("/")
+      @access_key = access_key
+      @secret_key = secret_key
+      @region = region
+    end
+
+    def list_buckets
+      response = request("GET", "/")
+      doc = REXML::Document.new(response.body)
+      doc.elements.collect("//Bucket/Name") do |e|
+        Bucket.new(name: e.text, created_at: Time.now)
+      end
+    end
+
+    def create_bucket(name)
+      request("PUT", "/#{name}")
+      true
+    end
+
+    def delete_bucket(name)
+      request("DELETE", "/#{name}")
+      true
+    end
+
+    def bucket_exists?(name)
+      request("HEAD", "/#{name}")
+      true
+    rescue Error
+      false
+    end
+
+    def list_objects(bucket, prefix: nil, max_keys: nil)
+      path = "/#{bucket}"
+      params = []
+      params << "prefix=#{URI.encode_www_form_component(prefix)}" if prefix
+      params << "max-keys=#{max_keys}" if max_keys
+      path += "?#{params.join("&")}" unless params.empty?
+
+      response = request("GET", path)
+      doc = REXML::Document.new(response.body)
+
+      doc.elements.collect("//Contents") do |e|
+        StorageObject.new(
+          key: e.elements["Key"]&.text,
+          size: e.elements["Size"]&.text&.to_i || 0,
+          etag: e.elements["ETag"]&.text&.gsub('"', ""),
+          last_modified: Time.now
+        )
+      end
+    end
+
+    def get_object(bucket, key)
+      response = request("GET", "/#{bucket}/#{key}")
+      response.body
+    end
+
+    def put_object(bucket, key, data, content_type: "application/octet-stream")
+      headers = { "Content-Type" => content_type }
+      response = request("PUT", "/#{bucket}/#{key}", body: data, headers: headers)
+      response["etag"]&.gsub('"', "") || ""
+    end
+
+    def delete_object(bucket, key)
+      request("DELETE", "/#{bucket}/#{key}")
+      true
+    end
+
+    def object_exists?(bucket, key)
+      request("HEAD", "/#{bucket}/#{key}")
+      true
+    rescue Error
+      false
+    end
+
+    private
+
+    def request(method, path, body: nil, headers: {})
+      uri = URI.parse("#{@endpoint}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request_class = {
+        "GET" => Net::HTTP::Get,
+        "PUT" => Net::HTTP::Put,
+        "DELETE" => Net::HTTP::Delete,
+        "HEAD" => Net::HTTP::Head
+      }[method]
+
+      req = request_class.new(uri)
+      headers.each { |k, v| req[k] = v }
+      req.body = body if body
+
+      if @access_key && @secret_key
+        sign_request(req, uri, body)
+      end
+
+      response = http.request(req)
+
+      unless response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPNoContent)
+        raise Error.new(response.body, response.code.to_i)
+      end
+
+      response
+    end
+
+    def sign_request(req, uri, body)
+      now = Time.now.utc
+      date_stamp = now.strftime("%Y%m%d")
+      amz_date = now.strftime("%Y%m%dT%H%M%SZ")
+
+      payload_hash = OpenSSL::Digest::SHA256.hexdigest(body || "")
+      req["x-amz-date"] = amz_date
+      req["x-amz-content-sha256"] = payload_hash
+
+      signed_headers = (req.to_hash.keys + ["host"]).sort.join(";")
+      canonical_headers = (req.to_hash.merge("host" => [uri.host])).sort.map { |k, v| "#{k}:#{v.join(",")}\n" }.join
+
+      canonical_request = [
+        req.method,
+        uri.path,
+        uri.query || "",
+        canonical_headers,
+        signed_headers,
+        payload_hash
+      ].join("\n")
+
+      algorithm = "AWS4-HMAC-SHA256"
+      credential_scope = "#{date_stamp}/#{@region}/s3/aws4_request"
+      string_to_sign = [
+        algorithm,
+        amz_date,
+        credential_scope,
+        OpenSSL::Digest::SHA256.hexdigest(canonical_request)
+      ].join("\n")
+
+      k_date = hmac_sha256("AWS4#{@secret_key}", date_stamp)
+      k_region = hmac_sha256(k_date, @region)
+      k_service = hmac_sha256(k_region, "s3")
+      k_signing = hmac_sha256(k_service, "aws4_request")
+      signature = OpenSSL::HMAC.hexdigest("SHA256", k_signing, string_to_sign)
+
+      req["Authorization"] = "#{algorithm} Credential=#{@access_key}/#{credential_scope}, SignedHeaders=#{signed_headers}, Signature=#{signature}"
+    end
+
+    def hmac_sha256(key, data)
+      OpenSSL::HMAC.digest("SHA256", key, data)
+    end
+  end
+end

data/lib/squirreldb/types.rb

@@ -0,0 +1,8 @@
+# SquirrelDB Ruby SDK - Types
+# Generated by sdk-generator v0.1.0
+# DO NOT EDIT MANUALLY
+
+# frozen_string_literal: true
+
+module SquirrelDB
+end

data/lib/squirreldb.rb

@@ -0,0 +1,14 @@
+# SquirrelDB Ruby SDK
+# Generated by sdk-generator v0.1.0
+# DO NOT EDIT MANUALLY
+
+# frozen_string_literal: true
+
+require_relative "squirreldb/types"
+require_relative "squirreldb/client"
+require_relative "squirreldb/storage"
+require_relative "squirreldb/cache"
+
+module SquirrelDB
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: squirreldb-sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SquirrelDB Contributors
+bindir: bin
+cert_chain: []
+date: 2026-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A Ruby client for connecting to SquirrelDB realtime database
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/squirreldb.rb
+- lib/squirreldb/cache.rb
+- lib/squirreldb/client.rb
+- lib/squirreldb/storage.rb
+- lib/squirreldb/types.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Ruby client for SquirrelDB
+test_files: []