gitdb-client 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d01ab528477d9adb2b3980cba474d466ae8205b7fc3a6993f944f01267535fe6
+  data.tar.gz: b514cb24a152505be3d7ce04fc05522c8298a7f856d99f91d6de2627993c6a55
+SHA512:
+  metadata.gz: 861df0078fa647d506a685ebb8d253fbe400e2a623ade1cdb0311036309de3404fb93332cc418c30da5e748bbdefb7122c57ff85b0361243209bc4cda4e5a666
+  data.tar.gz: 607cc8f8076cf5600d7af486723317016551454ad2f35c54b00a67e886d5791ddd2dd3854b8796f014ba872e8c2f950bc99818e575bf2f155678da3ab9c9976c

data/README.md

@@ -0,0 +1,469 @@
+# GitDB Ruby Client
+
+Official Ruby client for GitDB - GitHub-backed NoSQL database.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gitdb-client'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install gitdb-client
+```
+
+## Quick Start
+
+```ruby
+require 'gitdb_client'
+
+# Create a client instance
+client = GitDBClient.new('your-github-token', 'owner', 'repository')
+
+# Check server health
+client.health
+
+# Create a collection
+client.create_collection('users')
+
+# Insert a document
+document = {
+  name: 'John Doe',
+  email: 'john@example.com',
+  age: 30
+}
+
+id = client.insert('users', document)
+puts "Inserted document with ID: #{id}"
+
+# Find documents
+query = {
+  age: { '$gte' => 25 }
+}
+
+documents = client.find('users', query)
+puts "Found #{documents.length} documents"
+
+# Update a document
+update = { age: 31 }
+client.update('users', id, update)
+
+# Delete a document
+client.delete('users', id)
+```
+
+## Features
+
+- ✅ **Simple Ruby API** - Easy to use Ruby interface
+- ✅ **Full CRUD operations** - Create, Read, Update, Delete documents
+- ✅ **Query support** - MongoDB-style query operators
+- ✅ **Collection management** - Create, list, delete collections
+- ✅ **Error handling** - Comprehensive error handling
+- ✅ **HTTP client** - Built-in HTTP client with retry logic
+- ✅ **JSON handling** - Native JSON serialization/deserialization
+- ✅ **Ruby 2.6+ support** - Modern Ruby compatibility
+
+## Configuration
+
+### GitHub Token
+
+You'll need a GitHub Personal Access Token with the following permissions:
+- `repo` - Full control of private repositories
+- `workflow` - Update GitHub Action workflows
+
+Create a token at: https://github.com/settings/tokens
+
+### Client Initialization
+
+```ruby
+require 'gitdb_client'
+
+# Basic initialization
+client = GitDBClient.new('token', 'owner', 'repo')
+
+# With custom base URL (for self-hosted instances)
+client = GitDBClient.new('token', 'owner', 'repo', 'http://localhost:7896')
+```
+
+## API Reference
+
+### Client Creation
+
+```ruby
+# Create a new client
+client = GitDBClient.new(token, owner, repo)
+
+# Create client with custom URL
+client = GitDBClient.new(token, owner, repo, 'http://localhost:7896')
+```
+
+### Health Check
+
+```ruby
+# Check if server is healthy
+client.health
+```
+
+### Collection Management
+
+```ruby
+# Create a collection
+client.create_collection('users')
+
+# List all collections
+collections = client.list_collections
+collections.each do |collection|
+  puts "Collection: #{collection['name']} (#{collection['count']} documents)"
+end
+
+# Delete a collection
+client.delete_collection('users')
+```
+
+### Document Operations
+
+#### Insert
+
+```ruby
+document = {
+  name: 'Alice',
+  email: 'alice@example.com',
+  age: 25
+}
+
+id = client.insert('users', document)
+puts "Inserted with ID: #{id}"
+```
+
+#### Find
+
+```ruby
+# Find all documents
+all_users = client.find('users', nil)
+
+# Find with query
+query = {
+  age: { '$gte' => 30 }
+}
+older_users = client.find('users', query)
+
+# Find one document
+user = client.find_one('users', query)
+
+# Find by ID
+user = client.find_by_id('users', 'document-id')
+```
+
+#### Update
+
+```ruby
+update = {
+  age: 26,
+  last_updated: '2024-01-01'
+}
+
+client.update('users', 'document-id', update)
+```
+
+#### Delete
+
+```ruby
+# Delete by ID
+client.delete('users', 'document-id')
+
+# Delete multiple documents
+query = {
+  age: { '$lt' => 18 }
+}
+deleted_count = client.delete_many('users', query)
+```
+
+### Batch Operations
+
+```ruby
+# Insert multiple documents
+documents = [
+  { name: 'Alice', age: 25 },
+  { name: 'Bob', age: 30 },
+  { name: 'Charlie', age: 35 }
+]
+
+documents.each do |doc|
+  id = client.insert('users', doc)
+end
+
+# Update multiple documents
+query = {
+  age: { '$gte' => 25 }
+}
+
+update = {
+  category: 'senior'
+}
+
+updated_count = client.update_many('users', query, update)
+```
+
+### Query Operators
+
+The Ruby client supports MongoDB-style query operators:
+
+```ruby
+query = {}
+
+# Equal
+query[:age] = 30
+
+# Greater than
+query[:age] = { '$gt' => 25 }
+
+# Greater than or equal
+query[:age] = { '$gte' => 25 }
+
+# Less than
+query[:age] = { '$lt' => 50 }
+
+# Less than or equal
+query[:age] = { '$lte' => 50 }
+
+# In array
+query[:status] = { '$in' => ['active', 'pending'] }
+
+# Not in array
+query[:status] = { '$nin' => ['inactive', 'deleted'] }
+
+# Logical AND
+query[:'$and'] = [
+  { age: { '$gte' => 18 } },
+  { status: 'active' }
+]
+
+# Logical OR
+query[:'$or'] = [
+  { status: 'active' },
+  { status: 'pending' }
+]
+```
+
+## Error Handling
+
+The SDK provides comprehensive error handling:
+
+```ruby
+begin
+  document = client.find_by_id('users', 'non-existent-id')
+rescue GitDBError => e
+  puts "GitDB Error: #{e.message}"
+  puts "Status Code: #{e.status_code}"
+rescue => e
+  puts "General Error: #{e.message}"
+end
+```
+
+## Advanced Usage
+
+### Custom HTTP Client
+
+```ruby
+require 'httparty'
+
+# Create custom HTTP client
+http_client = HTTParty
+http_client.timeout = 30
+
+# Create GitDB client with custom HTTP client
+client = GitDBClient.new('token', 'owner', 'repo', http_client: http_client)
+```
+
+### Retry Logic
+
+```ruby
+# The client includes built-in retry logic for transient errors
+# You can configure retry behavior if needed
+client.max_retries = 3
+client.retry_delay = 1
+```
+
+## Examples
+
+### User Management System
+
+```ruby
+require 'gitdb_client'
+
+class User
+  attr_accessor :id, :name, :email, :age, :status, :created_at
+
+  def initialize(name, email, age)
+    @name = name
+    @email = email
+    @age = age
+    @status = 'active'
+    @created_at = Time.now
+  end
+
+  def to_hash
+    {
+      name: @name,
+      email: @email,
+      age: @age,
+      status: @status,
+      created_at: @created_at
+    }
+  end
+end
+
+class UserManager
+  def initialize(token, owner, repo)
+    @client = GitDBClient.new(token, owner, repo)
+  end
+
+  def create_user(name, email, age)
+    user = User.new(name, email, age)
+    @client.insert('users', user.to_hash)
+  end
+
+  def find_user_by_email(email)
+    query = { email: email }
+    @client.find_one('users', query)
+  end
+
+  def update_user_status(user_id, status)
+    update = { status: status }
+    @client.update('users', user_id, update)
+  end
+
+  def get_active_users
+    query = { status: 'active' }
+    @client.find('users', query)
+  end
+
+  def delete_inactive_users
+    query = { status: 'inactive' }
+    @client.delete_many('users', query)
+  end
+end
+
+# Usage
+user_manager = UserManager.new('your-token', 'owner', 'repo')
+
+# Create user
+user_id = user_manager.create_user('John Doe', 'john@example.com', 30)
+
+# Find user
+user = user_manager.find_user_by_email('john@example.com')
+
+# Update status
+user_manager.update_user_status(user_id, 'inactive')
+
+# Get active users
+active_users = user_manager.get_active_users
+puts "Active users: #{active_users.length}"
+```
+
+## Testing
+
+```ruby
+require 'rspec'
+require 'gitdb_client'
+
+RSpec.describe GitDBClient do
+  describe '#new' do
+    it 'creates a client instance' do
+      client = GitDBClient.new('token', 'owner', 'repo')
+      expect(client).to be_a(GitDBClient)
+    end
+  end
+
+  describe '#insert and #find_by_id' do
+    it 'inserts and finds a document' do
+      client = GitDBClient.new('token', 'owner', 'repo')
+
+      # Test document
+      document = {
+        name: 'Test User',
+        age: 25
+      }
+
+      # Insert
+      id = client.insert('test', document)
+
+      # Find by ID
+      found = client.find_by_id('test', id)
+
+      expect(found['name']).to eq('Test User')
+
+      # Cleanup
+      client.delete('test', id)
+    end
+  end
+end
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Authentication Error**
+   - Verify your GitHub token is valid
+   - Ensure token has required permissions
+   - Check token hasn't expired
+
+2. **Repository Access**
+   - Verify repository exists
+   - Check you have access to the repository
+   - Ensure repository is not private (unless using private GitDB)
+
+3. **Network Issues**
+   - Check internet connection
+   - Verify GitHub API is accessible
+   - Check firewall settings
+
+4. **Rate Limiting**
+   - GitHub API has rate limits
+   - Implement exponential backoff for retries
+   - Consider using authenticated requests
+
+### Debug Mode
+
+Enable debug mode to see detailed request/response information:
+
+```ruby
+# Set debug mode (if supported by the client)
+client.debug_mode = true
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests
+5. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.
+
+## Support
+
+- GitHub Issues: https://github.com/karthikeyanV2K/GitDB/issues
+- Documentation: https://github.com/karthikeyanV2K/GitDB
+- Email: Support@afot.in
+
+## Changelog
+
+### v1.0.0
+- Initial release
+- Full CRUD operations
+- Query support with MongoDB-style operators
+- Error handling
+- Comprehensive documentation 

data/gitdb-client.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |spec|
+  spec.name          = "gitdb-client"
+  spec.version       = "1.0.0"
+  spec.authors       = ["AFOT Team", "karthikeyanV2K"]
+  spec.email         = ["Support@afot.in", "karthikeyan@afot.in"]
+
+  spec.summary       = "Official Ruby client for GitDB - GitHub-backed NoSQL database"
+  spec.description   = "A Ruby client for GitDB, a GitHub-backed NoSQL database"
+  spec.homepage      = "https://github.com/karthikeyanV2K/GitDB"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage
+
+  spec.files         = [
+    "lib/gitdb_client.rb",
+    "gitdb-client.gemspec",
+    "README.md"
+  ]
+  # Removed bindir and executables
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "httparty", "~> 0.21"
+  spec.add_dependency "json", "~> 2.6"
+  
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end 

data/lib/gitdb_client.rb

@@ -0,0 +1,263 @@
+require 'net/http'
+require 'json'
+require 'uri'
+
+module GitDB
+  # GitDB Client for Ruby
+  # A client library for interacting with GitDB - GitHub-backed NoSQL database
+  class Client
+    attr_reader :base_url, :token, :owner, :repo
+
+    # Create a new GitDB client
+    # @param token [String] GitHub personal access token
+    # @param owner [String] GitHub username or organization
+    # @param repo [String] GitHub repository name
+    # @param base_url [String] GitDB server base URL
+    def initialize(token, owner, repo, base_url = 'http://localhost:7896')
+      @token = token
+      @owner = owner
+      @repo = repo
+      @base_url = base_url
+    end
+
+    # Set the base URL for the client
+    # @param url [String] new base URL
+    def set_base_url(url)
+      @base_url = url
+    end
+
+    # Check if the GitDB server is healthy
+    # @return [Boolean] true if healthy
+    # @raise [GitDBException] if health check fails
+    def health
+      response = make_request(:get, '/health')
+      response.code == '200'
+    end
+
+    # Create a new collection
+    # @param name [String] collection name
+    # @return [Boolean] true if created successfully
+    # @raise [GitDBException] if creation fails
+    def create_collection(name)
+      data = { name: name }
+      response = make_request(:post, '/api/v1/collections', data)
+      response.code == '201'
+    end
+
+    # List all collections
+    # @return [Array<Hash>] list of collections
+    # @raise [GitDBException] if listing fails
+    def list_collections
+      response = make_request(:get, '/api/v1/collections')
+      JSON.parse(response.body)
+    end
+
+    # Delete a collection
+    # @param name [String] collection name
+    # @return [Boolean] true if deleted successfully
+    # @raise [GitDBException] if deletion fails
+    def delete_collection(name)
+      response = make_request(:delete, "/api/v1/collections/#{name}")
+      response.code == '200'
+    end
+
+    # Insert a document into a collection
+    # @param collection [String] collection name
+    # @param document [Hash] document to insert
+    # @return [String] document ID
+    # @raise [GitDBException] if insertion fails
+    def insert(collection, document)
+      response = make_request(:post, "/api/v1/collections/#{collection}/documents", document)
+      
+      unless response.code == '201'
+        raise GitDBException, "Failed to insert document: #{response.code}"
+      end
+
+      result = JSON.parse(response.body)
+      result['_id'] or raise GitDBException, 'No document ID returned'
+    end
+
+    # Find documents in a collection
+    # @param collection [String] collection name
+    # @param query [Hash] query to execute
+    # @return [Array<Hash>] list of documents
+    # @raise [GitDBException] if query fails
+    def find(collection, query = {})
+      response = make_request(:post, "/api/v1/collections/#{collection}/documents/find", query)
+      
+      unless response.code == '200'
+        raise GitDBException, "Failed to find documents: #{response.code}"
+      end
+
+      JSON.parse(response.body)
+    end
+
+    # Find a single document in a collection
+    # @param collection [String] collection name
+    # @param query [Hash] query to execute
+    # @return [Hash, nil] document or nil if not found
+    # @raise [GitDBException] if query fails
+    def find_one(collection, query = {})
+      documents = find(collection, query)
+      documents.first
+    end
+
+    # Find a document by ID
+    # @param collection [String] collection name
+    # @param id [String] document ID
+    # @return [Hash] document
+    # @raise [GitDBException] if query fails
+    def find_by_id(collection, id)
+      response = make_request(:get, "/api/v1/collections/#{collection}/documents/#{id}")
+      
+      unless response.code == '200'
+        raise GitDBException, "Failed to find document: #{response.code}"
+      end
+
+      JSON.parse(response.body)
+    end
+
+    # Update a document by ID
+    # @param collection [String] collection name
+    # @param id [String] document ID
+    # @param update [Hash] update operations
+    # @return [Boolean] true if updated successfully
+    # @raise [GitDBException] if update fails
+    def update(collection, id, update)
+      response = make_request(:put, "/api/v1/collections/#{collection}/documents/#{id}", update)
+      response.code == '200'
+    end
+
+    # Update multiple documents
+    # @param collection [String] collection name
+    # @param query [Hash] query to match documents
+    # @param update [Hash] update operations
+    # @return [Integer] number of modified documents
+    # @raise [GitDBException] if update fails
+    def update_many(collection, query, update)
+      data = { query: query, update: update }
+      response = make_request(:post, "/api/v1/collections/#{collection}/documents/update-many", data)
+      
+      unless response.code == '200'
+        raise GitDBException, "Failed to update documents: #{response.code}"
+      end
+
+      result = JSON.parse(response.body)
+      result['modifiedCount'] || 0
+    end
+
+    # Delete a document by ID
+    # @param collection [String] collection name
+    # @param id [String] document ID
+    # @return [Boolean] true if deleted successfully
+    # @raise [GitDBException] if deletion fails
+    def delete(collection, id)
+      response = make_request(:delete, "/api/v1/collections/#{collection}/documents/#{id}")
+      response.code == '200'
+    end
+
+    # Delete multiple documents
+    # @param collection [String] collection name
+    # @param query [Hash] query to match documents
+    # @return [Integer] number of deleted documents
+    # @raise [GitDBException] if deletion fails
+    def delete_many(collection, query)
+      response = make_request(:post, "/api/v1/collections/#{collection}/documents/delete-many", query)
+      
+      unless response.code == '200'
+        raise GitDBException, "Failed to delete documents: #{response.code}"
+      end
+
+      result = JSON.parse(response.body)
+      result['deletedCount'] || 0
+    end
+
+    # Count documents in a collection
+    # @param collection [String] collection name
+    # @param query [Hash] query to match documents
+    # @return [Integer] document count
+    # @raise [GitDBException] if count fails
+    def count(collection, query = {})
+      response = make_request(:post, "/api/v1/collections/#{collection}/documents/count", query)
+      
+      unless response.code == '200'
+        raise GitDBException, "Failed to count documents: #{response.code}"
+      end
+
+      result = JSON.parse(response.body)
+      result['count'] || 0
+    end
+
+    # Execute a GraphQL query
+    # @param query [String] GraphQL query string
+    # @param variables [Hash, nil] GraphQL variables
+    # @return [Hash] GraphQL response
+    # @raise [GitDBException] if query fails
+    def graphql(query, variables = nil)
+      request_data = { query: query }
+      request_data[:variables] = variables if variables
+
+      response = make_request(:post, '/graphql', request_data)
+      
+      unless response.code == '200'
+        raise GitDBException, "Failed to execute GraphQL query: #{response.code}"
+      end
+
+      result = JSON.parse(response.body)
+      
+      if result['errors']
+        raise GitDBException, "GraphQL errors: #{result['errors']}"
+      end
+
+      result
+    end
+
+    private
+
+    # Make an HTTP request to the GitDB server
+    # @param method [Symbol] HTTP method
+    # @param path [String] API path
+    # @param data [Hash, nil] request data
+    # @return [Net::HTTPResponse] HTTP response
+    # @raise [GitDBException] if request fails
+    def make_request(method, path, data = nil)
+      uri = URI.parse("#{@base_url}#{path}")
+      
+      case method
+      when :get
+        request = Net::HTTP::Get.new(uri)
+      when :post
+        request = Net::HTTP::Post.new(uri)
+        request.body = data.to_json if data
+      when :put
+        request = Net::HTTP::Put.new(uri)
+        request.body = data.to_json if data
+      when :delete
+        request = Net::HTTP::Delete.new(uri)
+      else
+        raise GitDBException, "Unsupported HTTP method: #{method}"
+      end
+
+      request['Authorization'] = "Bearer #{@token}"
+      request['Content-Type'] = 'application/json'
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.read_timeout = 30
+      http.open_timeout = 30
+
+      response = http.request(request)
+      
+      unless response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+        raise GitDBException, "HTTP request failed: #{response.code} #{response.message}"
+      end
+
+      response
+    rescue => e
+      raise GitDBException, "Request failed: #{e.message}"
+    end
+  end
+
+  # Custom exception class for GitDB errors
+  class GitDBException < StandardError; end
+end 

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: gitdb-client
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- AFOT Team
+- karthikeyanV2K
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.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'
+description: A Ruby client for GitDB, a GitHub-backed NoSQL database
+email:
+- Support@afot.in
+- karthikeyan@afot.in
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- gitdb-client.gemspec
+- lib/gitdb_client.rb
+homepage: https://github.com/karthikeyanV2K/GitDB
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/karthikeyanV2K/GitDB
+  source_code_uri: https://github.com/karthikeyanV2K/GitDB
+  changelog_uri: https://github.com/karthikeyanV2K/GitDB
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Official Ruby client for GitDB - GitHub-backed NoSQL database
+test_files: []