wowsql-sdk 3.0.2 → 3.9.0

data/lib/wowsql/auth.rb

@@ -91,12 +91,12 @@ module WOWSQL
 
     # @param project_url [String] Project subdomain or full URL
     # @param api_key [String] API key for authentication
-    # @param base_domain [String] Base domain (default: "wowsql.com")
+    # @param base_domain [String] Base domain (default: "wowsqlconnect.com")
     # @param secure [Boolean] Use HTTPS (default: true)
     # @param timeout [Integer] Request timeout in seconds (default: 30)
     # @param verify_ssl [Boolean] Verify SSL certificates (default: true)
     # @param token_storage [TokenStorage, nil] Optional token storage
-    def initialize(project_url, api_key, base_domain: 'wowsql.com', secure: true,
+    def initialize(project_url, api_key, base_domain: 'wowsqlconnect.com', secure: true,
                    timeout: 30, verify_ssl: true, token_storage: nil)
       @api_key = api_key
       @timeout = timeout

data/lib/wowsql/client.rb

@@ -4,104 +4,97 @@ require_relative 'exceptions'
 require_relative 'table'
 
 module WOWSQL
-  # WOWSQL client for interacting with your database via REST API.
+  # WowSQL client for PostgREST-native database operations.
   #
-  # This client is used for DATABASE OPERATIONS (CRUD on tables).
-  # Use Service Role Key or Anonymous Key for authentication.
-  #
-  # Key Types:
-  #   - Service Role Key: Full access to all database operations (server-side)
-  #   - Anonymous Key: Public access with limited permissions (client-side)
+  # All requests are sent directly to the PostgREST endpoint (/rest/v1).
   #
   # @example
-  #   client = WOWSQL::WOWSQLClient.new(
-  #     "myproject",
-  #     "wowbase_service_..."
-  #   )
-  #   users = client.table("users").get
+  #   client = WOWSQL::WOWSQLClient.new("myproject", "wowsql_anon_...")
+  #   result = client.table("users").get
   class WOWSQLClient
-    attr_reader :api_url, :api_key, :timeout, :verify_ssl
+    attr_reader :api_url, :api_key, :timeout, :verify_ssl, :last_content_range
 
-    # @param project_url [String] Project subdomain or full URL
-    # @param api_key [String] API key for database operations
-    # @param base_domain [String] Base domain (default: "wowsql.com")
-    # @param secure [Boolean] Use HTTPS (default: true)
-    # @param timeout [Integer] Request timeout in seconds (default: 30)
-    # @param verify_ssl [Boolean] Verify SSL certificates (default: true)
-    def initialize(project_url, api_key, base_domain: 'wowsql.com', secure: true, timeout: 30, verify_ssl: true)
-      @api_key = api_key
-      @timeout = timeout
+    # @param project_url [String]  Project slug, domain, or full URL
+    # @param api_key     [String]  Anonymous or service role key
+    # @param base_domain [String]  Base domain appended when project_url is a slug (default: wowsqlconnect.com)
+    # @param secure      [Boolean] Use HTTPS (default: true)
+    # @param timeout     [Integer] Request timeout in seconds (default: 30)
+    # @param verify_ssl  [Boolean] Verify SSL certificates (default: true)
+    def initialize(project_url, api_key,
+                   base_domain: 'wowsqlconnect.com',
+                   secure: true,
+                   timeout: 30,
+                   verify_ssl: true)
+      @api_key    = api_key
+      @timeout    = timeout
       @verify_ssl = verify_ssl
+      @last_content_range = nil
 
-      if project_url.start_with?('http://') || project_url.start_with?('https://')
-        base_url = project_url.chomp('/')
-        if base_url.include?('/api')
-          base_url = base_url.split('/api').first
-          @api_url = "#{base_url}/api/v2"
-        else
-          @api_url = "#{base_url}/api/v2"
-        end
+      if project_url.start_with?('http://', 'https://')
+        base = project_url.chomp('/')
+        base = base.split('/api').first if base.include?('/api')
+        @base_url = base
       else
         protocol = secure ? 'https' : 'http'
         if project_url.include?(".#{base_domain}") || project_url.end_with?(base_domain)
-          @api_url = "#{protocol}://#{project_url}/api/v2"
+          @base_url = "#{protocol}://#{project_url}"
         else
-          @api_url = "#{protocol}://#{project_url}.#{base_domain}/api/v2"
+          @base_url = "#{protocol}://#{project_url}.#{base_domain}"
         end
       end
 
+      @api_url = "#{@base_url}/rest/v1"
+
       ssl_options = verify_ssl ? {} : { verify: false }
 
       @conn = Faraday.new(url: @api_url, ssl: ssl_options) do |f|
-        f.request :json
+        f.request  :json
         f.response :json
-        f.adapter Faraday.default_adapter
+        f.adapter  Faraday.default_adapter
         f.options.timeout = timeout
       end
 
-      @conn.headers['Authorization'] = "Bearer #{api_key}"
+      @conn.headers['apikey']       = api_key
       @conn.headers['Content-Type'] = 'application/json'
     end
 
-    # Get a table interface for fluent API.
+    # Return a Table interface for the given table name.
     #
-    # @param table_name [String] Name of the table
-    # @return [Table] Table instance for the specified table
+    # @param table_name [String]
+    # @return [Table]
     def table(table_name)
       Table.new(self, table_name)
     end
 
-    # List all tables in the database.
-    #
-    # @return [Array<String>] List of table names
-    def list_tables
-      response = request('GET', '/tables', nil, nil)
-      response['tables'] || []
+    def realtime
+      @realtime ||= WowSQLRealtime.new(@base_url, @api_key)
     end
 
-    # Get table schema information.
-    #
-    # @param table_name [String] Name of the table
-    # @return [Hash] Table schema with columns and primary key
-    def get_table_schema(table_name)
-      request('GET', "/tables/#{table_name}/schema", nil, nil)
-    end
-
-    # Close the HTTP connection.
+    # Close the HTTP connection (no-op, provided for API parity).
     def close
       @conn.close if @conn.respond_to?(:close)
     end
 
-    # Make HTTP request to API.
-    def request(method, path, params = nil, json = nil)
+    # Make an HTTP request to the PostgREST endpoint.
+    #
+    # @param method  [String]      HTTP method
+    # @param path    [String]      Path (relative to /rest/v1)
+    # @param params  [Hash, nil]   Query parameters
+    # @param json    [Hash, nil]   Request body
+    # @param headers [Hash, nil]   Additional headers (e.g. Prefer, on-conflict)
+    # @return [Array, Hash, nil]
+    def request(method, path, params = nil, json = nil, headers = nil)
       response = @conn.public_send(method.downcase, path) do |req|
-        req.params = params if params
-        req.body = json if json
+        req.params  = params  if params
+        req.body    = json    if json
+        req.headers = req.headers.merge(headers) if headers
       end
 
+      @last_content_range = response.headers['content-range']
+
       if response.status >= 400
         error_data = response.body.is_a?(Hash) ? response.body : {}
-        error_msg = error_data['detail'] || error_data['message'] || "Request failed with status #{response.status}"
+        error_msg  = error_data['message'] || error_data['detail'] || "Request failed with status #{response.status}"
         raise WOWSQLError.new(error_msg, response.status, error_data)
       end
 
@@ -109,5 +102,16 @@ module WOWSQL
     rescue Faraday::Error => e
       raise WOWSQLError.new("Request failed: #{e.message}")
     end
+
+    # Parse total count from a Content-Range header value.
+    #
+    # @param header   [String, nil]  e.g. "0-19/100"
+    # @param fallback [Integer]
+    # @return [Integer]
+    def self.parse_total_from_content_range(header, fallback)
+      return fallback unless header&.include?('/')
+      val = header.split('/').last.to_i
+      val > 0 ? val : fallback
+    end
   end
 end