memori-client 0.1.9 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2514386c5093864c79a74f317030cf2ab058fbd41a3337decfc5415d8a3182b4
-  data.tar.gz: e33a09045201dbd2ceea70acf767e73037f368de5223a157b99c1959bd4b7406
+  metadata.gz: 7592af5e2d26be8087d2a19c7e5159a4fabbecc4c009975ccbd9578281ab26be
+  data.tar.gz: ed1fbe1cbc4af3d2013ec9ea40c9b67bb7a3bd4058dbd7cd220750ff95797368
 SHA512:
-  metadata.gz: 258e0813e4c0998df0e1f746d02984a55eb249de7adec552ccedec1b6eb3b906e0e7b43834659e099ec0268891adc6c6914bf7050737f021e7e84e8c3a0207a3
-  data.tar.gz: '0795c94a010caac4a6697eb1d8833b852eff369e00ee00dab0f2c74d95b8ed980d322f614fd655ee092e059499087d36a9312becefa749071c37ae0cf6f23f38'
+  metadata.gz: da3adc611208ccb5ca49c04b5734b9c43e97679956341552a9af2f4f080db316203ad5b4a8ba476a02b1f0ea7c377526dc9435f4cd62b47d2cd7ec30e00ebcf0
+  data.tar.gz: f114260a0ee34f9b6085b60201df408419ba554978d83af9e21ee0c329a40cc58364e158f3628ec83ce1ad519d82d592ad729e1eb13e312ab036976924230c1b

data/backend_overrides.jsonc

@@ -0,0 +1,4 @@
+{
+    // TODO: remove
+    "get /api/v2/Tenant/{tenantName}": "MemoriClient::Backend::V2::Tenant#get_public_tenant"
+}

data/engine_overrides.jsonc

@@ -0,0 +1,3 @@
+{
+
+}

data/lib/memori_client/client.rb

@@ -0,0 +1,49 @@
+require 'pry'
+class MemoriClient::Client
+  attr_reader :version_proxies
+  attr_reader :namespace
+  attr_reader :kind
+  def initialize(namespace:, kind:, uri:, api_root:)
+    @namespace = namespace
+    @kind = kind
+    @uri = uri
+    @api_root = api_root
+    @version_proxies = {}
+  end
+
+  def load_swagger_spec
+    if @swagger.nil?
+      @swagger = MemoriClient::Swagger::ProcessSpecification.new(uri: @uri, kind: @kind).call
+      @swagger.each do |key, list|
+        register_resource(key, list)
+      end
+    end
+  end
+
+  private
+
+  def register_resource(key, list)
+    _, _, version, klass = key.split('::')
+    version.downcase!
+    klass = klass.underscore
+    if @version_proxies[version].nil?
+      version_proxy = MemoriClient::ResourceProxy.new(api_root: @api_root, version: version)
+      @version_proxies[version] = version_proxy
+    else
+      version_proxy = @version_proxies[version]
+    end
+
+    resource = version_proxy.register_resource(klass)
+    list.each do |item|
+      resource.register_operation(item)
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    if @version_proxies.key?(method.to_s)
+      @version_proxies[method.to_s]
+    else
+      super
+    end
+  end
+end

data/lib/memori_client/client_factory.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module MemoriClient
+  # ClientFactory is a singleton class responsible for creating and caching
+  # MemoriClient::Client instances for different namespaces and kinds.
+  #
+  # This factory pattern ensures that only one client instance exists per
+  # namespace/kind combination, improving performance and resource usage.
+  #
+  # @example Basic usage
+  #   factory = MemoriClient::ClientFactory.instance
+  #   client = factory.get_client(
+  #     namespace: 'my_app',
+  #     kind: MemoriClient::ClientFactory::Kinds::BACKEND,
+  #     uri: 'https://api.example.com',
+  #     api_root: '/api/v1'
+  #   )
+  #
+  # @since 1.0.0
+  class ClientFactory
+    include Singleton
+
+    # Defines the available client kinds that can be created by the factory.
+    # Each kind represents a different type of service or API endpoint.
+    module Kinds
+      # Backend API client for core application services
+      BACKEND = 'backend'
+      
+      # Engine API client for processing and analysis services
+      ENGINE = 'engine'
+    end
+
+    # Initializes a new ClientFactory instance.
+    # Sets up empty hashes to cache backend and engine clients by namespace.
+    def initialize
+      @backend_clients = {}
+      @engine_clients = {}
+    end
+
+    # Gets or creates a cached client instance for the specified parameters.
+    #
+    # This method implements a lazy initialization pattern where clients are
+    # only created when first requested and then cached for subsequent use.
+    #
+    # @param namespace [String] The namespace identifier for the client.
+    #   Used as a cache key to ensure unique clients per namespace.
+    # @param kind [String] The type of client to create.
+    #   Must be one of the values defined in {Kinds}.
+    # @param uri [String] The base URI for the Swagger specification.
+    # @param api_root [String] The API root URL.
+    #
+    # @return [MemoriClient::Client] A cached or newly created client instance.
+    #
+    # @raise [RuntimeError] If an invalid kind is provided.
+    #
+    # @example Get a backend client
+    #   client = factory.get_client(
+    #     namespace: 'production',
+    #     kind: Kinds::BACKEND,
+    #     uri: 'https://api.memori.ai',
+    #     api_root: '/api/v1'
+    #   )
+    #
+    # @example Get an engine client
+    #   client = factory.get_client(
+    #     namespace: 'staging',
+    #     kind: Kinds::ENGINE,
+    #     uri: 'https://engine.memori.ai',
+    #     api_root: '/engine/v1'
+    #   )
+    def get_client(namespace:, kind:, uri:, api_root:)
+      # Validate that the provided kind is supported
+      raise "Invalid kind: #{kind}" unless known_kinds.include?(kind)
+
+      case kind
+      when Kinds::BACKEND
+        # Use memoization to return cached client or create new one
+        @backend_clients[namespace] ||= MemoriClient::Client.new(namespace: namespace, 
+          kind: kind, 
+          uri: uri, 
+          api_root: api_root)
+      when Kinds::ENGINE
+        # Use memoization to return cached client or create new one
+        @engine_clients[namespace] ||= MemoriClient::Client.new(namespace: namespace, 
+          kind: kind, 
+          uri: uri, 
+          api_root: api_root)
+      end
+    end
+
+    private
+
+    # Returns an array of all known client kinds.
+    #
+    # This method dynamically retrieves all constants defined in the Kinds module
+    # to provide a list of valid client types for validation.
+    #
+    # @return [Array<String>] Array of valid client kind strings.
+    def known_kinds
+      Kinds.constants.map do |k|
+        Kernel.const_get "MemoriClient::ClientFactory::Kinds::#{k}"
+      end
+    end
+  end
+end

data/lib/memori_client/engine/hmac_helper.rb

@@ -8,7 +8,7 @@ class MemoriClient::Engine::HMACHelper
 
   def initialize(app_id, key, max_delta_secs = 30)
     # Check arguments
-    raise ArgumentError, "HMAC: invalid appID" if app_id.nil?
+    raise ArgumentError, "HMAC: invalid appID" if app_id.nil? || app_id <= 0 || app_id == ''
     raise ArgumentError, "HMAC: invalid key" if key.nil? || key.to_s == "00000000-0000-0000-0000-000000000000"
 
     # Initialization

data/lib/memori_client/http_client.rb

@@ -12,7 +12,7 @@ class MemoriClient::HttpClient
     request = Net::HTTP::Get.new(uri)
     headers.each { |k, v| request[k] = v }
     request["Content-Type"] ||= "application/json" unless headers.key?('Content-Type')
-    request.basic_auth(*basic_auth) if basic_auth.present?
+    request.basic_auth(*basic_auth) if !basic_auth.nil?
 
     req_options = { use_ssl: uri.scheme == "https" }
     response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
@@ -35,6 +35,7 @@ class MemoriClient::HttpClient
   end
 
   def post(url, headers: {}, payload:)
+    puts "post #{url}"
     url = URI(url)
     https = Net::HTTP.new(url.host, url.port)
     https.use_ssl = url.scheme == 'https'
@@ -47,6 +48,7 @@ class MemoriClient::HttpClient
   end
 
   def post_file(url, file:)
+    puts "post_file #{url}"
     url = URI(url)
     https = Net::HTTP.new(url.host, url.port)
     https.use_ssl = url.scheme == 'https'
@@ -71,21 +73,6 @@ class MemoriClient::HttpClient
   private
 
   def handle_response(response, request)
-    body = response.read_body
-
-    if request['Content-Type'] == 'application/json'
-      if body.nil? || body == ''
-        response_body = {}
-      else
-        response_body = JSON.parse(body)
-      end
-
-      [
-        response.code,
-        (body.nil? ? {} : response_body)
-      ]
-    else
-      [response.code, body]
-    end
+    MemoriClient::Response.new(response, request: request)
   end
 end

data/lib/memori_client/operation.rb

@@ -0,0 +1,132 @@
+module MemoriClient
+  class Operation
+    def initialize(item, version:, key:)
+      @item = item
+      @version = version
+      @key = key
+    end
+
+    def generate_method_code(method)
+      module_name = method[:module]
+      method_name = method[:method_name]
+      qualified_method = [module_name, method_name].join('#')
+    
+      params_list = []
+      (method[:params] || {}).each do |k, required|
+        if required
+          params_list << "#{k}:"
+        else
+          params_list << "#{k}: nil"
+        end
+      end
+  
+      params_definition = (method[:spec]['parameters'] || []).map do |param|
+        {
+          name: param['name'],
+          description: param['description'],
+          required: param['required'] == true,
+          type: param['schema']['type']
+        }
+      end
+  
+      payload_keys = []
+      payload_required_keys = []
+  
+      if method[:request_body]
+        params_list << "payload: {}"
+  
+        params_definition << {
+          name: 'payload',
+          description: 'request payload',
+          required: false,
+          type: 'Hash',
+        }
+  
+        request_body_schema_ref = method.dig(:spec, 'requestBody', 'content', 'application/json', 'schema', '$ref')
+  
+        # Note:
+        # capturing required keys is not exact as sometimes there are two keys where
+        # only one must be present or at least one.
+        # So we report requirement of the key in the documentation but we do not
+        # enforce any check on the presence.
+        # We validate the valid key instead
+        key = request_body_schema_ref.split('/').last
+        schema = MemoriClient::Swagger::SchemaStore.instance.get(key)
+        required_keys = schema['required'] || []
+        schema['properties'].each do |key, value|
+          required = value['nullable'] == false || required_keys.include?(key)
+          payload_keys << key
+          payload_required_keys << key if required
+          params_definition << {
+            name: "payload.#{key}",
+            description: '',
+            required: required,
+            type: value['type']&.titleize,
+            indent: 2
+          }
+        end
+      end
+  
+      payload_keys.sort!
+      payload_required_keys.sort!
+      signature = "#{method_name}(#{params_list.join(', ')})"
+  
+      params_list_doc = params_definition.each_with_object([]) do |param, acc|
+        if param[:indent]
+          prefix = " " * param[:indent]
+        else
+          prefix = ""
+        end
+        acc << "#{prefix}- `#{param[:name]}`: **#{param[:type]}** #{param[:description]}. #{param[:required] ? 'required' : 'optional' }"
+      end.join("\n")
+  
+      optional_payload_code = ''
+      if payload_keys.size > 0
+        optional_payload_code = <<-EOS
+        payload_keys = [
+  #{payload_keys.map { |k| "        '#{k}'," }.join("\n") }
+        ]
+        payload_required_keys = %w[#{payload_required_keys.join(' ')}]
+        validate_payload!(args[:payload], keys: payload_keys, required: payload_required_keys)
+        EOS
+      end
+  
+      output = <<-EOS
+## #{method_name}
+  
+Summary:
+#{method[:summary].gsub("\n", ' ').gsub("\r", ' ')}
+  
+Signature: `#{signature}`
+Invokation: `client.#{@version}.#{@key.downcase}.#{signature}`
+  
+HTTP API: #{method[:method].upcase} #{method[:path]}`
+  
+      EOS
+  
+      if params_list_doc.size > 0
+        output << <<-EOS
+Parameters:
+  
+#{params_list_doc}
+        EOS
+      end
+  
+      output << "\n"
+  
+      output
+    end
+
+    def markdown_documentation
+        # #{@item[:method_name]}
+        #{@item[:path]}
+        <<~MARKDOWN
+#{generate_method_code(@item)}
+      MARKDOWN
+    end
+
+    def spec
+      @item
+    end
+  end
+end

data/lib/memori_client/proxy/client.rb

@@ -0,0 +1,115 @@
+require 'net/http'
+require 'json'
+require 'open-uri'
+
+# Initialize a DB Proxy Client, which connects to the AIsuru proxy client to interact with
+# backend and engine databases, in read-only mode.
+# Usage:
+#
+# client = AisuruProxyClient.new(base_url: "https://...", api_key: "XXX")
+#
+# Status:
+# client.status
+#
+# Tables list and table information
+# client.tables(id: 'backend', schema: 'memoriai')
+# client.table_schema(id: 'backend', schema: 'memoriai', table: 'ActionLog')
+#
+# SQL Query
+# sql = <<~SQL
+# SELECT * FROM memoriai."ActionLog"
+# LIMIT 10
+# OFFSET 0
+# SQL
+# client.query(id: 'backend', sql: sql)
+class MemoriClient::Proxy::Client
+  CONNECTIONS = ['backend', 'engine'].freeze
+
+  # @param base_url [String] The base URL for the API
+  # @param api_key [String] The API key for authentication
+  def initialize(base_url:, api_key:)
+    @base_url = base_url
+    @api_key = api_key
+  end
+
+  # Get the status of the API
+  def status
+    path = "api/v1/status"
+    uri = URI.join(@base_url, path)
+    response = get(uri)
+    [response.code, response.body]
+  end
+
+  # Get a list of tables for a specific connection
+  # @param id [String] The connection ID
+  # @param schema [String] The schema name (optional)
+  def tables(id:, schema: nil)
+    unless CONNECTIONS.include?(id)
+      raise ArgumentError, "Invalid connection id: #{id}"
+    end
+
+    path = "api/v1/#{id}/tables"
+    path += "?schema=#{schema}" if schema
+    uri = URI.join(@base_url, path)
+    response = get(uri)
+    [response.code, response.body]
+  end
+
+  # Get the schema of a specific table
+  # @param id [String] The connection ID
+  # @param schema [String] The schema name (optional)
+  # @param table [String] The table name
+  def table_schema(id:, schema: nil, table:)
+    unless CONNECTIONS.include?(id)
+      raise ArgumentError, "Invalid connection id: #{id}"
+    end
+    
+    path = "api/v1/#{id}/tables/#{table}/schema"
+    path += "?schema=#{schema}" if schema
+    uri = URI.join(@base_url, path)
+    response = get(uri)
+    [response.code, response.body]
+  end
+
+  # Execute a SQL query
+  # @param id [String] The connection ID
+  # @param sql [String] The SQL query
+  def query(id:, sql:)
+    unless CONNECTIONS.include?(id)
+      raise ArgumentError, "Invalid connection id: #{id}"
+    end
+    
+    path = "api/v1/#{id}/query"
+    uri = URI.join(@base_url, path)
+    response = post_raw_content(uri, sql)
+    [response.code, response.body]
+  end
+
+  private
+
+  def get(uri)
+    request = Net::HTTP::Get.new(uri)
+    request["X-Api-Key"] = @api_key
+    
+    req_options = { use_ssl: uri.scheme == "https" }
+    response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+      http.request(request)
+    end
+    response
+  end
+
+  def post_raw_content(uri, content)
+    request = Net::HTTP::Post.new(uri)
+    request["X-Api-Key"] = @api_key
+    request["Content-Type"] = "text/plain"
+    request["Accept"] = "application/json"
+    request.body = content
+
+    req_options = { use_ssl: uri.scheme == "https" }
+
+    response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+      http.request(request)
+    end
+    response
+  end
+end