getstream-ruby 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 765739a719bbe2275fb36cde41f1879ccfff08e3d5c74ac5ddcae6b6dc8bfe20
+  data.tar.gz: 41229097883827200bfa4f61bb21b0b28e947d133a253cd77cb47a38c77fe1a5
+SHA512:
+  metadata.gz: fea0955dc3bbe4f3586631be3f0a1525abb76c4dabb76e2110a82af663d79fa250e01662710b03d5894eaf620cc2cf7d2fbcebb11cf4fa9301049d5cc883e846
+  data.tar.gz: 2a501dc2e2b76c097cca0cfc520f896f9b0566ff9bc710238d4b85c3b9f97af9dd986f0fe93d466a36930a6c7754156b14b2078de84162f25be93213b9064881

data/README.md

@@ -0,0 +1,332 @@
+# GetStream Ruby SDK this
+
+Official Ruby SDK for GetStream's activity feeds and chat APIs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'getstream-ruby'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install getstream-ruby
+```
+
+## Configuration
+
+### Method 1: Manual (Highest Priority)
+
+```ruby
+require 'getstream_ruby'
+
+client = GetStreamRuby.manual(
+  api_key: "your_api_key",
+  api_secret: "your_api_secret",
+)
+```
+
+### Method 2: .env File
+
+Create a `.env` file in your project root:
+
+```bash
+# Copy the example file
+cp env.example .env
+
+# Edit .env with your actual credentials
+STREAM_API_KEY=your_api_key
+STREAM_API_SECRET=your_api_secret
+```
+
+```ruby
+require 'getstream_ruby'
+
+# Uses .env file automatically
+client = GetStreamRuby.env
+# or
+client = GetStreamRuby.client  # defaults to .env
+```
+
+### Method 3: Environment Variables
+
+```bash
+export STREAM_API_KEY=your_api_key
+export STREAM_API_SECRET=your_api_secret
+```
+
+```ruby
+require 'getstream_ruby'
+
+client = GetStreamRuby.env_vars
+```
+
+## Usage
+
+### Basic Setup
+
+```ruby
+# Create a client instance
+client = GetStreamRuby.client
+
+# Or create with custom configuration
+client = GetStreamRuby::Client.new(config)
+```
+
+### Feed Operations
+
+#### Create a Feed
+
+```ruby
+# Create a user feed
+feed_response = client.feed.create("user", "123", {
+  name: "John Doe",
+  email: "john@example.com"
+})
+```
+
+#### Add Activity to Feed
+
+```ruby
+# Add an activity
+activity_response = client.feed.add_activity("user", "123", {
+  actor: "user:123",
+  verb: "post",
+  object: "post:456",
+  message: "Hello, world!",
+  published: Time.now.iso8601
+})
+```
+
+#### Get Feed Activities
+
+```ruby
+# Get activities from a feed
+activities = client.feed.get_activities("user", "123", {
+  limit: 10,
+  offset: 0
+})
+```
+
+#### Follow/Unfollow Feeds
+
+```ruby
+# Follow another user
+follow_response = client.feed.follow("user:123", "user:456", {
+  activity_copy_limit: 5
+})
+
+# Unfollow a user
+unfollow_response = client.feed.unfollow("user:123", "user:456")
+```
+
+## Error Handling
+
+The SDK provides specific error classes for different types of errors:
+
+```ruby
+begin
+  client.feed.create("user", "123")
+rescue GetStreamRuby::AuthenticationError => e
+  puts "Authentication failed: #{e.message}"
+rescue GetStreamRuby::ValidationError => e
+  puts "Validation error: #{e.message}"
+rescue GetStreamRuby::APIError => e
+  puts "API error: #{e.message}"
+end
+```
+
+## Development
+
+### Quick Start
+
+```bash
+# Clone the repository
+git clone https://github.com/getstream/getstream-ruby.git
+cd getstream-ruby
+
+# Setup development environment
+make dev-setup
+
+# Run all checks
+make dev-check
+```
+
+### Project Structure
+
+```
+getstream-ruby/
+├── lib/getstream_ruby/          # Main SDK code
+├── spec/                        # Test files
+│   ├── integration/             # Integration tests
+│   └── *.rb                     # Unit tests
+├── .github/workflows/           # CI/CD workflows
+├── .rubocop.yml                 # Code style configuration
+├── .env.example                 # Environment template
+├── Makefile                     # Development commands
+├── Rakefile                     # Ruby task runner
+└── Gemfile                      # Dependencies
+```
+
+### Development Commands
+
+This project includes a simple Makefile with essential commands:
+
+#### Setup & Installation
+```bash
+make install          # Install dependencies
+make setup            # Setup development environment
+make dev-setup        # Complete development setup
+```
+
+#### Testing
+```bash
+make test             # Run unit tests only
+make test-integration # Run integration tests only
+make test-all         # Run all tests (unit + integration)
+```
+
+#### Code Quality
+```bash
+make format           # Auto-format code with RuboCop
+make format-check     # Check formatting (CI-friendly)
+make lint             # Run RuboCop linter
+make security         # Run security audit
+make dev-check        # Run all development checks
+```
+
+#### Utilities
+```bash
+make clean            # Clean up generated files
+make console          # Start IRB console with SDK loaded
+make version          # Show current version
+make help             # Show all available commands
+```
+
+### Environment Setup
+
+1. **Copy environment template:**
+   ```bash
+   cp .env.example .env
+   ```
+
+2. **Edit `.env` with your GetStream credentials:**
+   ```bash
+   STREAM_API_KEY=your_api_key
+   STREAM_API_SECRET=your_api_secret
+   ```
+
+3. **Run tests:**
+   ```bash
+   make test-all
+   ```
+
+### Ruby & Bundler Compatibility
+
+This project supports Ruby 2.6+ and uses the default bundler version for simplicity.
+
+**Requirements:**
+- Ruby 2.6.0+ (see `.ruby-version`)
+- Bundler (latest compatible version)
+
+### Code Style
+
+This project uses RuboCop for code style enforcement. The configuration is in `.rubocop.yml`.
+
+- **Auto-fix issues:** `make format-fix`
+- **Check style:** `make format-check`
+- **View all issues:** `make lint`
+
+### Development Tools
+
+The project includes several development tools configured and ready to use:
+
+- **RuboCop** - Code style and quality enforcement
+- **RSpec** - Testing framework
+- **SimpleCov** - Code coverage reporting
+- **YARD** - Documentation generation
+- **Bundler Audit** - Security vulnerability scanning
+- **WebMock** - HTTP request mocking (disabled for integration tests)
+
+### Available Makefile Commands
+
+Run `make help` to see all available commands, or check the sections above for categorized commands.
+
+### Integration Tests
+
+Integration tests require valid GetStream API credentials. They test real API interactions:
+
+```bash
+# Run integration tests (requires .env file)
+make test-integration
+
+# Run specific integration test
+bundle exec rspec spec/integration/feed_integration_spec.rb
+bundle exec rspec spec/integration/moderation_integration_spec.rb
+```
+
+### CI/CD
+
+The project includes simple GitHub Actions workflows:
+
+- **CI Pipeline:** Runs on every push and pull request
+  - Unit tests
+  - Code formatting checks
+  - Security audit
+  - Integration tests (on master/main branches only)
+
+- **Release Pipeline:** Manual releases via git tags
+  - Create a tag: `git tag v1.0.0 && git push origin v1.0.0`
+  - Automated gem build and release
+
+#### GitHub Environment Variables
+
+To enable integration tests in CI, configure these GitHub repository settings:
+
+1. **Create a "ci" environment:**
+   - Go to Settings → Environments
+   - Click "New environment"
+   - Name it "ci"
+
+2. **Configure environment variables:**
+   - In the "ci" environment, go to Environment variables
+   - Add: `STREAM_API_KEY` = your GetStream API key
+
+3. **Configure environment secrets:**
+   - In the "ci" environment, go to Environment secrets
+   - Add: `STREAM_API_SECRET` = your GetStream API secret
+
+### Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature-name`
+3. Make your changes
+4. Run tests: `make dev-check`
+5. Commit with conventional messages: `git commit -m "feat: add new feature"`
+6. Push and create a pull request
+
+**Commit Message Format:**
+- `feat:` - New features
+- `fix:` - Bug fixes
+- `docs:` - Documentation changes
+- `style:` - Code style changes
+- `refactor:` - Code refactoring
+- `test:` - Test changes
+- `chore:` - Maintenance tasks
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/getstream/getstream-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/getstream_ruby/client.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/retry'
+require 'json'
+require 'jwt'
+require_relative 'generated/base_model'
+require_relative 'generated/common_client'
+require_relative 'generated/feeds_client'
+require_relative 'generated/moderation_client'
+require_relative 'generated/feed'
+require_relative 'stream_response'
+
+module GetStreamRuby
+
+  class Client
+
+    attr_reader :configuration
+
+    def initialize(config = nil, api_key: nil, api_secret: nil, base_url: nil, timeout: nil)
+      @configuration = config || GetStreamRuby.configuration
+
+      # Create new configuration with overrides if any parameters provided
+      if api_key || api_secret || base_url || timeout
+        @configuration = Configuration.with_overrides(
+          api_key: api_key,
+          api_secret: api_secret,
+          base_url: base_url,
+          timeout: timeout,
+        )
+      end
+
+      @configuration.validate!
+      @connection = build_connection
+    end
+
+    def feed_resource
+      @feed_resource ||= Resources::Feed.new(self)
+    end
+
+    # Generated API clients
+
+    # @return [GetStream::Generated::CommonClient] The common API client
+    def common
+      @common ||= GetStream::Generated::CommonClient.new(self)
+    end
+
+    # @return [GetStream::Generated::FeedsClient] The feeds API client
+    def feeds
+      @feeds ||= GetStream::Generated::FeedsClient.new(self)
+    end
+
+    # @return [GetStream::Generated::ModerationClient] The moderation API client
+    def moderation
+      @moderation ||= GetStream::Generated::ModerationClient.new(self)
+    end
+
+    # Create an individual feed instance
+    # @param feed_group_id [String] The feed group ID
+    # @param feed_id [String] The feed ID
+    # @return [GetStream::Generated::Feed] A feed instance
+    def feed(feed_group_id, feed_id)
+      GetStream::Generated::Feed.new(self, feed_group_id, feed_id)
+    end
+
+    # @param path [String] The API path
+    # @param body [Hash] The request body
+    # @return [GetStreamRuby::StreamResponse] The API response
+    def post(path, body = {})
+      request(:post, path, body)
+    end
+
+    def make_request(method, path, query_params: nil, body: nil)
+      # Handle query parameters
+      if query_params && !query_params.empty?
+        query_string = query_params.map { |k, v| "#{k}=#{v}" }.join('&')
+        path = "#{path}?#{query_string}"
+      end
+
+      # Make the request
+      request(method, path, body)
+    end
+
+    private
+
+    def request(method, path, data = {})
+      # Add API key to query parameters
+      query_params = { api_key: @configuration.api_key }
+      response = @connection.send(method) do |req|
+
+        req.url path, query_params
+        req.headers['Authorization'] = generate_auth_header
+        req.headers['Content-Type'] = 'application/json'
+        req.headers['stream-auth-type'] = 'jwt'
+        req.headers['X-Stream-Client'] = user_agent
+        req.body = data.to_json
+
+      end
+
+      handle_response(response)
+    rescue Faraday::Error => e
+      raise APIError, "Request failed: #{e.message}"
+    end
+
+    def build_connection
+      Faraday.new(url: @configuration.base_url) do |conn|
+
+        conn.request :retry, {
+          max: 3,
+          interval: 0.05,
+          interval_randomness: 0.5,
+          backoff_factor: 2,
+        }
+        conn.response :json, content_type: /\bjson$/
+        conn.adapter Faraday.default_adapter
+        conn.options.timeout = @configuration.timeout
+
+      end
+    end
+
+    def generate_auth_header
+      JWT.encode(
+        {
+          iat: Time.now.to_i,
+          server: true,
+        },
+        @configuration.api_secret,
+        'HS256',
+      )
+    end
+
+    def user_agent
+      "getstream-ruby-#{GetStreamRuby::VERSION}"
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        StreamResponse.new(response.body)
+      else
+        # Parse JSON response body if it's a string
+        parsed_body = if response.body.is_a?(String)
+                        begin
+                          JSON.parse(response.body)
+                        rescue JSON::ParserError
+                          response.body
+                        end
+                      else
+                        response.body
+                      end
+
+        error_message = if parsed_body.is_a?(Hash)
+                          parsed_body['message'] || parsed_body['detail'] ||
+                            "Request failed with status #{response.status}"
+                        else
+                          "Request failed with status #{response.status}"
+                        end
+        raise APIError, error_message
+      end
+    end
+
+  end
+
+end

data/lib/getstream_ruby/configuration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module GetStreamRuby
+
+  class Configuration
+
+    attr_accessor :api_key, :api_secret, :base_url, :timeout, :logger
+
+    def initialize(api_key: nil, api_secret: nil, base_url: nil, timeout: nil, use_env: true)
+      if use_env
+        @api_key = api_key || ENV.fetch('STREAM_API_KEY', nil)
+        @api_secret = api_secret || ENV.fetch('STREAM_API_SECRET', nil)
+        @base_url = base_url || ENV['STREAM_BASE_URL'] || 'https://chat.stream-io-api.com'
+        @timeout = timeout || (ENV['STREAM_TIMEOUT'] || 30).to_i
+      else
+        # Manual configuration only - no environment variables
+        @api_key = api_key
+        @api_secret = api_secret
+        @base_url = base_url || 'https://api.getstream.io/api/v1.0'
+        @timeout = timeout || 30
+      end
+
+      @logger = nil
+    end
+
+    def valid?
+      api_key && api_secret
+    end
+
+    def validate!
+      raise ConfigurationError, 'API key is required' unless api_key
+      raise ConfigurationError, 'API secret is required' unless api_secret
+    end
+
+    def dup
+      Configuration.new(
+        api_key: @api_key,
+        api_secret: @api_secret,
+        base_url: @base_url,
+        timeout: @timeout,
+      )
+    end
+
+    # Class method to create configuration with overrides
+    def self.with_overrides(overrides = {})
+      new(**overrides)
+    end
+
+    # Method 1: Manual configuration (no environment variables)
+    def self.manual(api_key:, api_secret:, base_url: nil, timeout: nil)
+      new(api_key: api_key, api_secret: api_secret,
+          base_url: base_url, timeout: timeout, use_env: false)
+    end
+
+    # Method 2: .env file (loads .env file via dotenv gem, falls back to env vars)
+    def self.from_env
+      require 'dotenv/load' if File.exist?('.env') && !File.empty?('.env') && !defined?(Dotenv)
+      new(use_env: true)
+    end
+
+    # Method 3: Environment variables (no .env file, direct system env)
+    def self.from_system_env
+      new(use_env: true)
+    end
+
+  end
+
+end

data/lib/getstream_ruby/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GetStreamRuby
+
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class APIError < Error; end
+
+end

data/lib/getstream_ruby/generated/base_model.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GetStream
+  # Base model class for all generated models
+  class BaseModel
+    def initialize(attributes = {})
+      # Set attributes from hash
+      attributes.each do |key, value|
+        method_name = "#{key}="
+        if respond_to?(method_name)
+          send(method_name, value)
+        end
+      end
+    end
+
+    # Convert to hash
+    def to_h
+      instance_variables.each_with_object({}) do |var, hash|
+        key = var.to_s.delete('@').to_sym
+        value = instance_variable_get(var)
+        hash[key] = value
+      end
+    end
+
+    # Convert to JSON
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    # Equality comparison
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      to_h == other.to_h
+    end
+
+    # String representation
+    def inspect
+      "#<#{self.class.name} #{to_h.inspect}>"
+    end
+  end
+end