edgebase_core 0.1.4

data/lib/edgebase_core/generated/client_wrappers.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+# Auto-generated client wrapper methods — DO NOT EDIT.
+#
+# Regenerate: npx tsx tools/sdk-codegen/generate.ts
+# Source: wrapper-config.json + openapi.json (0.1.0)
+
+module EdgebaseCore
+  class GeneratedAuthMethods
+    # Authentication wrapper methods
+
+    def initialize(core)
+      @core = core
+    end
+
+    # Sign up with email and password
+    def sign_up(body = nil)
+      @core.auth_signup(body)
+    end
+
+    # Sign in with email and password
+    def sign_in(body = nil)
+      @core.auth_signin(body)
+    end
+
+    # Sign out and revoke refresh token
+    def sign_out(body = nil)
+      @core.auth_signout(body)
+    end
+
+    # Sign in anonymously
+    def sign_in_anonymously(body = nil)
+      @core.auth_signin_anonymous(body)
+    end
+
+    # Send magic link to email
+    def sign_in_with_magic_link(body = nil)
+      @core.auth_signin_magic_link(body)
+    end
+
+    # Verify magic link token
+    def verify_magic_link(body = nil)
+      @core.auth_verify_magic_link(body)
+    end
+
+    # Send OTP SMS to phone number
+    def sign_in_with_phone(body = nil)
+      @core.auth_signin_phone(body)
+    end
+
+    # Verify phone OTP and create session
+    def verify_phone(body = nil)
+      @core.auth_verify_phone(body)
+    end
+
+    # Send OTP code to email
+    def sign_in_with_email_otp(body = nil)
+      @core.auth_signin_email_otp(body)
+    end
+
+    # Verify email OTP and create session
+    def verify_email_otp(body = nil)
+      @core.auth_verify_email_otp(body)
+    end
+
+    # Link phone number to existing account
+    def link_with_phone(body = nil)
+      @core.auth_link_phone(body)
+    end
+
+    # Verify OTP and link phone to account
+    def verify_link_phone(body = nil)
+      @core.auth_verify_link_phone(body)
+    end
+
+    # Link email and password to existing account
+    def link_with_email(body = nil)
+      @core.auth_link_email(body)
+    end
+
+    # Request email change with password confirmation
+    def change_email(body = nil)
+      @core.auth_change_email(body)
+    end
+
+    # Verify email change token
+    def verify_email_change(body = nil)
+      @core.auth_verify_email_change(body)
+    end
+
+    # Verify email address with token
+    def verify_email(body = nil)
+      @core.auth_verify_email(body)
+    end
+
+    # Request password reset email
+    def request_password_reset(body = nil)
+      @core.auth_request_password_reset(body)
+    end
+
+    # Reset password with token
+    def reset_password(body = nil)
+      @core.auth_reset_password(body)
+    end
+
+    # Change password for authenticated user
+    def change_password(body = nil)
+      @core.auth_change_password(body)
+    end
+
+    # Get current authenticated user info
+    def get_me()
+      @core.auth_get_me()
+    end
+
+    # Update user profile
+    def update_profile(body = nil)
+      @core.auth_update_profile(body)
+    end
+
+    # List active sessions
+    def list_sessions()
+      @core.auth_get_sessions()
+    end
+
+    # Delete a session
+    def revoke_session(id)
+      @core.auth_delete_session(id)
+    end
+
+    # Enroll new TOTP factor
+    def enroll_totp()
+      @core.auth_mfa_totp_enroll()
+    end
+
+    # Confirm TOTP enrollment with code
+    def verify_totp_enrollment(body = nil)
+      @core.auth_mfa_totp_verify(body)
+    end
+
+    # Verify MFA code during signin
+    def verify_totp(body = nil)
+      @core.auth_mfa_verify(body)
+    end
+
+    # Use recovery code during MFA signin
+    def use_recovery_code(body = nil)
+      @core.auth_mfa_recovery(body)
+    end
+
+    # Disable TOTP factor
+    def disable_totp(body = nil)
+      @core.auth_mfa_totp_delete(body)
+    end
+
+    # List MFA factors for authenticated user
+    def list_factors()
+      @core.auth_mfa_factors()
+    end
+
+    # Generate passkey registration options
+    def passkeys_register_options()
+      @core.auth_passkeys_register_options()
+    end
+
+    # Verify and store passkey registration
+    def passkeys_register(body = nil)
+      @core.auth_passkeys_register(body)
+    end
+
+    # Generate passkey authentication options
+    def passkeys_auth_options(body = nil)
+      @core.auth_passkeys_auth_options(body)
+    end
+
+    # Authenticate with passkey
+    def passkeys_authenticate(body = nil)
+      @core.auth_passkeys_authenticate(body)
+    end
+
+    # List passkeys for authenticated user
+    def passkeys_list()
+      @core.auth_passkeys_list()
+    end
+
+    # Delete a passkey
+    def passkeys_delete(credential_id)
+      @core.auth_passkeys_delete(credential_id)
+    end
+  end
+
+  class GeneratedStorageMethods
+    # Storage wrapper methods (bucket-scoped)
+
+    def initialize(core)
+      @core = core
+    end
+
+    # Delete file
+    def delete(bucket, key)
+      @core.delete_file(bucket, key)
+    end
+
+    # Batch delete files
+    def delete_many(bucket, body = nil)
+      @core.delete_batch(bucket, body)
+    end
+
+    # Check if file exists
+    def exists(bucket, key)
+      @core.check_file_exists(bucket, key)
+    end
+
+    # Get file metadata
+    def get_metadata(bucket, key)
+      @core.get_file_metadata(bucket, key)
+    end
+
+    # Update file metadata
+    def update_metadata(bucket, key, body = nil)
+      @core.update_file_metadata(bucket, key, body)
+    end
+
+    # Create signed download URL
+    def create_signed_url(bucket, body = nil)
+      @core.create_signed_download_url(bucket, body)
+    end
+
+    # Batch create signed download URLs
+    def create_signed_urls(bucket, body = nil)
+      @core.create_signed_download_urls(bucket, body)
+    end
+
+    # Create signed upload URL
+    def create_signed_upload_url(bucket, body = nil)
+      @core.create_signed_upload_url(bucket, body)
+    end
+
+    # Start multipart upload
+    def create_multipart_upload(bucket, body = nil)
+      @core.create_multipart_upload(bucket, body)
+    end
+
+    # Complete multipart upload
+    def complete_multipart_upload(bucket, body = nil)
+      @core.complete_multipart_upload(bucket, body)
+    end
+
+    # Abort multipart upload
+    def abort_multipart_upload(bucket, body = nil)
+      @core.abort_multipart_upload(bucket, body)
+    end
+  end
+
+  class GeneratedAnalyticsMethods
+    # Analytics wrapper methods
+
+    def initialize(core)
+      @core = core
+    end
+
+    # Track custom events
+    def track(body = nil)
+      @core.track_events(body)
+    end
+  end
+
+end

data/lib/edgebase_core/http_client.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+require_relative "context_manager"
+require_relative "errors"
+
+module EdgebaseCore
+  DEFAULT_OPEN_TIMEOUT = 30
+  DEFAULT_READ_TIMEOUT = 120
+
+  # Synchronous HTTP client for server-side use.
+  #
+  # Features:
+  # - Service Key header injection (X-EdgeBase-Service-Key)
+  # - Optional Bearer token injection (for impersonation)
+  # - Legacy context state for compatibility (not serialized into HTTP headers)
+  class HttpClient
+    attr_reader :base_url
+
+    def initialize(base_url, context_manager: nil, service_key: nil, bearer_token: nil)
+      @base_url = base_url.chomp("/")
+      @context_manager = context_manager || ContextManager.new
+      @service_key = service_key
+      @bearer_token = bearer_token
+    end
+
+    def get(path, params: nil)
+      request("GET", path, params: params)
+    end
+
+    def post(path, body = nil, params: nil)
+      request("POST", path, params: params, json_body: body)
+    end
+
+    def patch(path, body = nil, params: nil)
+      request("PATCH", path, params: params, json_body: body)
+    end
+
+    def put(path, body = nil, params: nil)
+      request("PUT", path, params: params, json_body: body)
+    end
+
+    def delete(path, params: nil)
+      request("DELETE", path, params: params)
+    end
+
+    # HEAD request — returns true if resource exists (2xx).
+    def head(path)
+      uri = URI(build_url(path))
+      http = build_http(uri)
+      req = Net::HTTP::Head.new(uri)
+      auth_headers.each { |k, v| req[k] = v }
+      response = http.request(req)
+      response.code.to_i < 400
+    end
+
+    # POST multipart form data (for file uploads).
+    def post_multipart(path, files:, data: nil)
+      uri = URI(build_url(path))
+      http = build_http(uri)
+
+      boundary = "EdgeBase#{rand(10**16)}"
+      body = build_multipart_body(files, data, boundary)
+
+      req = Net::HTTP::Post.new(uri)
+      headers = auth_headers
+      headers.delete("Content-Type")
+      headers["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+      headers.each { |k, v| req[k] = v }
+      req.body = body
+
+      parse_response(http.request(req))
+    end
+
+    # POST raw binary data (for multipart upload-part).
+    def post_raw(path, data:, content_type: "application/octet-stream")
+      uri = URI(build_url(path))
+      http = build_http(uri)
+
+      req = Net::HTTP::Post.new(uri)
+      headers = auth_headers
+      headers["Content-Type"] = content_type
+      headers.each { |k, v| req[k] = v }
+      req.body = data
+
+      parse_response(http.request(req))
+    end
+
+    # GET raw bytes (for file downloads).
+    def get_raw(path)
+      uri = URI(build_url(path))
+      http = build_http(uri)
+      req = Net::HTTP::Get.new(uri)
+      auth_headers.each { |k, v| req[k] = v }
+      response = http.request(req)
+      if response.code.to_i >= 400
+        raise EdgeBaseError.new(response.code.to_i, response.body)
+      end
+      response.body
+    end
+
+    private
+
+    def request(method, path, params: nil, json_body: nil)
+      url = build_url(path)
+      if params && !params.empty?
+        query = URI.encode_www_form(params)
+        url = "#{url}?#{query}"
+      end
+
+      uri = URI(url)
+      http = build_http(uri)
+
+      req = case method
+            when "GET"    then Net::HTTP::Get.new(uri)
+            when "POST"   then Net::HTTP::Post.new(uri)
+            when "PATCH"  then Net::HTTP::Patch.new(uri)
+            when "PUT"    then Net::HTTP::Put.new(uri)
+            when "DELETE" then Net::HTTP::Delete.new(uri)
+            else Net::HTTP::Get.new(uri)
+            end
+
+      auth_headers.each { |k, v| req[k] = v }
+      req.body = JSON.generate(json_body) if json_body
+
+      parse_response(http.request(req))
+    end
+
+    def build_url(path)
+      if path.start_with?("/api/")
+        "#{@base_url}#{path}"
+      else
+        "#{@base_url}/api#{path}"
+      end
+    end
+
+    def auth_headers
+      headers = { "Content-Type" => "application/json", "Connection" => "close" }
+      begin
+        if @bearer_token
+          headers["Authorization"] = "Bearer #{@bearer_token}"
+        end
+        if @service_key
+          headers["X-EdgeBase-Service-Key"] = @service_key
+          headers["Authorization"] = "Bearer #{@service_key}"
+        end
+      rescue StandardError
+        # Token refresh failed — proceed as unauthenticated
+      end
+      headers
+    end
+
+    def build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = request_timeout_seconds(DEFAULT_OPEN_TIMEOUT)
+      http.read_timeout = request_timeout_seconds(DEFAULT_READ_TIMEOUT)
+      http.keep_alive_timeout = 0 if http.respond_to?(:keep_alive_timeout=)
+      http
+    end
+
+    def request_timeout_seconds(default_seconds)
+      raw = ENV.fetch("EDGEBASE_HTTP_TIMEOUT_MS", "").strip
+      return default_seconds if raw.empty?
+
+      timeout_ms = Integer(raw, exception: false)
+      return default_seconds if timeout_ms.nil? || timeout_ms <= 0
+
+      timeout_ms / 1000.0
+    end
+
+    def parse_response(response)
+      code = response.code.to_i
+      if code >= 400
+        begin
+          data = JSON.parse(response.body)
+          raise EdgeBaseError.from_json(data, code)
+        rescue EdgeBaseError
+          raise
+        rescue StandardError
+          raise EdgeBaseError.new(code, response.body || "Unknown error")
+        end
+      end
+
+      return nil if response.body.nil? || response.body.empty?
+
+      begin
+        JSON.parse(response.body)
+      rescue StandardError
+        raise EdgeBaseError.new(code, "Expected a JSON response but received malformed JSON.")
+      end
+    end
+
+    def build_multipart_body(files, data, boundary)
+      body = +""
+      # Data fields
+      if data
+        data.each do |key, value|
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"
+          body << "#{value}\r\n"
+        end
+      end
+      # File fields
+      files.each do |field_name, (filename, file_data, content_type)|
+        body << "--#{boundary}\r\n"
+        body << "Content-Disposition: form-data; name=\"#{field_name}\"; filename=\"#{filename}\"\r\n"
+        body << "Content-Type: #{content_type}\r\n\r\n"
+        body << file_data
+        body << "\r\n"
+      end
+      body << "--#{boundary}--\r\n"
+      body
+    end
+  end
+end

data/lib/edgebase_core/storage.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "uri"
+require "base64"
+
+module EdgebaseCore
+  # Signed URL result.
+  SignedUrlResult = Struct.new(:url, :expires_in, keyword_init: true)
+
+  # File metadata.
+  FileInfo = Struct.new(:key, :size, :content_type, :etag, :custom_metadata, keyword_init: true) do
+    def self.from_json(data)
+      new(
+        key: data["key"] || "",
+        size: data["size"] || 0,
+        content_type: data["contentType"],
+        etag: data["etag"],
+        custom_metadata: data["customMetadata"] || data["custom_metadata"] || {}
+      )
+    end
+  end
+
+  # Storage subsystem — bucket factory.
+  #
+  #   bucket = client.storage.bucket("avatars")
+  #   url = bucket.get_url("profile.png")
+  class StorageClient
+    def initialize(client)
+      @client = client
+    end
+
+    def bucket(name)
+      StorageBucket.new(@client, name)
+    end
+  end
+
+  # Bucket-level storage operations.
+  class StorageBucket
+    attr_reader :name
+
+    def initialize(client, name)
+      @client = client
+      @core = EdgebaseCore::GeneratedDbApi.new(client)
+      @name = name
+    end
+
+    # Get the public URL of a file.
+    def get_url(path)
+      "#{@client.base_url}/api/storage/#{@name}/#{URI.encode_www_form_component(path)}"
+    end
+
+    # ── Upload ─────────────────────────────────────────────────────────────
+
+    def upload(path, data, content_type: "application/octet-stream")
+      @client.post_multipart(
+        "/storage/#{@name}/upload",
+        files: { "file" => [path, data, content_type] },
+        data: { "key" => path }
+      )
+    end
+
+    def upload_string(path, data, encoding: "raw", content_type: "text/plain")
+      raw_bytes = case encoding
+                  when "raw"
+                    data.encode("UTF-8")
+                  when "base64"
+                    Base64.decode64(data)
+                  when "base64url"
+                    Base64.urlsafe_decode64(data)
+                  when "data_url"
+                    _, encoded = data.split(",", 2)
+                    Base64.decode64(encoded)
+                  else
+                    data.encode("UTF-8")
+                  end
+      upload(path, raw_bytes, content_type: content_type)
+    end
+
+    # ── Download ───────────────────────────────────────────────────────────
+
+    def download(path)
+      @client.get_raw("/storage/#{@name}/#{URI.encode_www_form_component(path)}")
+    end
+
+    # ── Metadata ───────────────────────────────────────────────────────────
+
+    def get_metadata(path)
+      data = @core.get_file_metadata(@name, path)
+      FileInfo.from_json(data)
+    end
+
+    def update_metadata(path, metadata)
+      @core.update_file_metadata(@name, path, metadata)
+    end
+
+    # ── Signed URLs ────────────────────────────────────────────────────────
+
+    def create_signed_url(path, expires_in: "1h")
+      data = @core.create_signed_download_url(
+        @name, { "key" => path, "expiresIn" => expires_in }
+      )
+      SignedUrlResult.new(url: data["url"] || "", expires_in: data["expiresIn"] || expires_in)
+    end
+
+    def create_signed_upload_url(path, expires_in: 3600)
+      data = @core.create_signed_upload_url(
+        @name, { "key" => path, "expiresIn" => "#{expires_in}s" }
+      )
+      SignedUrlResult.new(url: data["url"] || "", expires_in: data["expiresIn"] || expires_in)
+    end
+
+    # ── Management ─────────────────────────────────────────────────────────
+
+    def delete_file(path)
+      @core.delete_file(@name, path)
+    end
+
+    alias delete delete_file
+
+    def list_files(prefix: "", limit: 100, offset: 0)
+      params = { "limit" => limit.to_s, "offset" => offset.to_s }
+      params["prefix"] = prefix unless prefix.empty?
+      data = @client.get("/storage/#{@name}", params: params)
+      items = data.is_a?(Hash) ? (data["files"] || data["items"] || []) : []
+      items.map { |item| FileInfo.from_json(item) }
+    end
+
+    alias list list_files
+
+    # ── Resumable / Multipart Upload ───────────────────────────────────────
+
+    def initiate_resumable_upload(path, content_type: "application/octet-stream", total_size: nil)
+      body = { "key" => path, "contentType" => content_type }
+      body["totalSize"] = total_size if total_size
+      data = @core.create_multipart_upload(@name, body)
+      data["uploadId"] || ""
+    end
+
+    def resume_upload(path, upload_id, chunk, part_number: 1, is_last_chunk: false)
+      encoded_path = URI.encode_www_form_component(path)
+      params = "uploadId=#{upload_id}&partNumber=#{part_number}&key=#{encoded_path}"
+      @client.post_raw(
+        "/storage/#{@name}/multipart/upload-part?#{params}",
+        data: chunk,
+        content_type: "application/octet-stream"
+      )
+    end
+
+    def complete_resumable_upload(path, upload_id, parts)
+      @core.complete_multipart_upload(
+        @name, { "uploadId" => upload_id, "key" => path, "parts" => parts }
+      )
+    end
+
+    def abort_resumable_upload(path, upload_id)
+      @core.abort_multipart_upload(
+        @name, { "uploadId" => upload_id, "key" => path }
+      )
+    end
+  end
+end