rodoo 0.1.0

data/README.md

@@ -0,0 +1,230 @@
+# Rodoo
+
+A Ruby gem wrapping Odoo's JSON-RPC 2.0 API (Odoo v19+) with an Active Record-style interface.
+
+## Requirements
+
+- Ruby 3.0+
+- Odoo v19 or higher (uses the `/json/2/` API endpoint)
+- Odoo API key for authentication
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "rodoo"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install rodoo
+```
+
+## Configuration
+
+### Using environment variables
+
+Rodoo automatically reads `ODOO_URL` and `ODOO_API_KEY` from the environment:
+
+```bash
+export ODOO_URL="https://your-instance.odoo.com"
+export ODOO_API_KEY="your-api-key"
+```
+
+### Explicit configuration
+
+```ruby
+Rodoo.configure do |config|
+  config.url = "https://your-instance.odoo.com"
+  config.api_key = "your-api-key"
+  config.timeout = 30          # Request timeout in seconds (default: 30)
+  config.open_timeout = 10     # Connection timeout in seconds (default: 10)
+  config.logger = Logger.new($stdout)
+  config.log_level = :debug    # :info or :debug (default: :info)
+end
+```
+
+## Usage
+
+### Finding records
+
+```ruby
+# Find by ID
+contact = Rodoo::Contact.find(42)
+contact.name  # => "Acme Corp"
+contact.email # => "contact@acme.com"
+
+# Find by attributes
+contact = Rodoo::Contact.find_by(email: "john@example.com")
+contact = Rodoo::Contact.find_by(name: "Acme Corp", is_company: true)
+
+# Find by string condition
+contact = Rodoo::Contact.find_by("credit_limit > 1000")
+
+# Find by raw domain
+contact = Rodoo::Contact.find_by([["name", "ilike", "%acme%"]])
+
+# Find by attributes (raises NotFoundError if not found)
+contact = Rodoo::Contact.find_by!(email: "john@example.com")
+```
+
+### Querying records
+
+Rodoo supports multiple query syntaxes for convenience:
+
+```ruby
+# Keyword arguments (equality)
+companies = Rodoo::Contact.where(is_company: true)
+active_companies = Rodoo::Contact.where(is_company: true, active: true)
+
+# String conditions (parsed automatically)
+high_credit = Rodoo::Contact.where("credit_limit > 1000")
+
+# Multiple string conditions
+filtered = Rodoo::Contact.where(["credit_limit > 1000", "active = true"])
+
+# Raw Odoo domain syntax (for complex queries)
+# See: https://www.odoo.com/documentation/19.0/developer/reference/backend/orm.html#reference-orm-domains
+contacts = Rodoo::Contact.where([["name", "ilike", "%acme%"]])
+
+# With pagination
+contacts = Rodoo::Contact.where(is_company: true, limit: 10, offset: 20)
+
+# Select specific fields
+contacts = Rodoo::Contact.where(active: true, fields: ["name", "email"])
+
+# Fetch all (with optional limit)
+all_contacts = Rodoo::Contact.all(limit: 100)
+```
+
+Supported operators in string conditions: `=`, `!=`, `<>`, `<`, `>`, `<=`, `>=`, `like`, `ilike`, `=like`, `=ilike`
+
+### Creating records
+
+```ruby
+# Create and persist immediately
+contact = Rodoo::Contact.create(
+  name: "New Contact",
+  email: "new@example.com",
+  is_company: false
+)
+contact.id  # => 123
+
+# Build and save later
+contact = Rodoo::Contact.new(name: "Draft Contact")
+contact.email = "draft@example.com"
+contact.save
+```
+
+### Updating records
+
+```ruby
+contact = Rodoo::Contact.find(42)
+
+# Update specific attributes
+contact.update(email: "updated@example.com", phone: "+1234567890")
+
+# Or modify and save
+contact.email = "another@example.com"
+contact.save
+
+# Reload from Odoo
+contact.reload
+```
+
+### Deleting records
+
+```ruby
+contact = Rodoo::Contact.find(42)
+contact.destroy
+
+contact.destroyed?  # => true
+```
+
+### Available models
+
+Rodoo includes pre-built models for common Odoo objects:
+
+| Class | Odoo Model |
+|-------|------------|
+| `Rodoo::Contact` | `res.partner` |
+| `Rodoo::Project` | `project.project` |
+| `Rodoo::AnalyticAccount` | `account.analytic.account` |
+| `Rodoo::AnalyticPlan` | `account.analytic.plan` |
+| `Rodoo::AccountingEntry` | `account.move` (all types) |
+| `Rodoo::CustomerInvoice` | `account.move` (move_type: out_invoice) |
+| `Rodoo::ProviderInvoice` | `account.move` (move_type: in_invoice) |
+| `Rodoo::CustomerCreditNote` | `account.move` (move_type: out_refund) |
+| `Rodoo::ProviderCreditNote` | `account.move` (move_type: in_refund) |
+| `Rodoo::JournalEntry` | `account.move` (move_type: entry) |
+
+### Custom models
+
+Create your own model by inheriting from `Rodoo::Model`:
+
+```ruby
+class Product < Rodoo::Model
+  model_name "product.product"
+end
+
+# Use it like any other model
+product = Product.find(1)
+products = Product.where(type: "consu", limit: 10)
+```
+
+### Error handling
+
+Rodoo provides a structured exception hierarchy:
+
+```ruby
+begin
+  contact = Rodoo::Contact.find(999999)
+rescue Rodoo::NotFoundError => e
+  puts "Contact not found: #{e.message}"
+rescue Rodoo::AuthenticationError => e
+  puts "Invalid credentials"
+rescue Rodoo::AccessDeniedError => e
+  puts "Permission denied"
+rescue Rodoo::ValidationError => e
+  puts "Validation failed: #{e.message}"
+rescue Rodoo::TimeoutError => e
+  puts "Request timed out"
+rescue Rodoo::ConnectionError => e
+  puts "Connection failed: #{e.message}"
+rescue Rodoo::APIError => e
+  puts "API error: #{e.message} (code: #{e.code})"
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+```bash
+rake test      # Run tests
+rake rubocop   # Run linter
+rake           # Run both
+bin/console    # Interactive REPL
+```
+
+To install the gem locally:
+
+```bash
+bundle exec rake install
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dekuple/rodoo.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/rodoo/configuration.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rodoo
+  class Configuration
+    VALID_OPTIONS = %i[
+      url
+      api_key
+      timeout
+      open_timeout
+      logger
+      log_level
+    ].freeze
+
+    attr_accessor(*VALID_OPTIONS)
+
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_OPEN_TIMEOUT = 10
+    DEFAULT_LOG_LEVEL = :info
+
+    def initialize
+      @url = ENV.fetch("ODOO_URL", nil)
+      @api_key = ENV.fetch("ODOO_API_KEY", nil)
+      @timeout = DEFAULT_TIMEOUT
+      @open_timeout = DEFAULT_OPEN_TIMEOUT
+      @log_level = DEFAULT_LOG_LEVEL
+    end
+
+    def validate!
+      raise ConfigurationError, "url is required" if url.nil? || url.empty?
+      raise ConfigurationError, "api_key or username/password is required" unless api_key
+
+      true
+    end
+
+    # Returns a hash of all options (useful for debugging)
+    def to_h
+      VALID_OPTIONS.each_with_object({}) do |key, hash|
+        hash[key] = send(key)
+      end
+    end
+  end
+end

data/lib/rodoo/connection.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Rodoo
+  class Connection
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+      @uri = URI.parse(config.url)
+    end
+
+    def execute(model, method, params = {})
+      path = "/json/2/#{model}/#{method}"
+      response = post(path, params)
+      handle_response(response)
+    end
+
+    private
+
+    def post(path, payload)
+      http = build_http_client
+      request = build_request(path, payload)
+      log_request(path, payload)
+      response = http.request(request)
+      log_response(response)
+      response
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise TimeoutError.new("Request timed out", original_error: e)
+    rescue SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET => e
+      raise ConnectionError.new("Failed to connect to #{config.url}", original_error: e)
+    end
+
+    def build_http_client
+      Net::HTTP.new(@uri.host, @uri.port).tap do |http|
+        http.use_ssl = @uri.scheme == "https"
+        http.read_timeout = config.timeout
+        http.open_timeout = config.open_timeout
+      end
+    end
+
+    def build_request(path, payload)
+      Net::HTTP::Post.new(path).tap do |request|
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{config.api_key}" if config.api_key
+        request.body = payload.to_json
+      end
+    end
+
+    def handle_response(response)
+      case response
+      when Net::HTTPSuccess
+        parse_response(response.body)
+      when Net::HTTPUnauthorized
+        raise AuthenticationError.new("Invalid credentials", code: response.code)
+      when Net::HTTPForbidden
+        raise AccessDeniedError.new("Access denied", code: response.code)
+      when Net::HTTPNotFound
+        raise NotFoundError.new("Endpoint not found", code: response.code)
+      else
+        raise_api_error(response)
+      end
+    end
+
+    def raise_api_error(response)
+      error_data = parse_error_body(response.body)
+      unless error_data
+        raise APIError.new("HTTP #{response.code}: #{response.message}", code: response.code)
+      end
+
+      error_class = map_odoo_exception(error_data[:name])
+      message = error_data[:message] || "HTTP #{response.code}: #{response.message}"
+      raise error_class.new(message, code: response.code, data: error_data)
+    end
+
+    def parse_error_body(body)
+      return nil if body.nil? || body.empty?
+
+      JSON.parse(body, symbolize_names: true)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def map_odoo_exception(exception_name)
+      case exception_name
+      when /ValidationError/, /UserError/
+        ValidationError
+      when /AccessError/, /AccessDenied/
+        AccessDeniedError
+      when /MissingError/
+        NotFoundError
+      else
+        APIError
+      end
+    end
+
+    def parse_response(body)
+      return nil if body.nil? || body.empty?
+
+      JSON.parse(body, symbolize_names: true)
+    rescue JSON::ParserError => e
+      raise Error.new("Invalid JSON response", original_error: e)
+    end
+
+    def log_request(path, payload)
+      return unless config.logger
+
+      if config.log_level == :debug
+        config.logger.debug("[Rodoo] POST #{path} #{payload.to_json}")
+      else
+        config.logger.info("[Rodoo] POST #{path}")
+      end
+    end
+
+    def log_response(response)
+      return unless config.logger
+
+      if config.log_level == :debug
+        config.logger.debug("[Rodoo] Response #{response.code}: #{response.body}")
+      else
+        config.logger.info("[Rodoo] Response #{response.code}")
+      end
+    end
+  end
+end

data/lib/rodoo/domain_builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rodoo
+  # Converts various condition formats into Odoo domain arrays.
+  #
+  # Supports:
+  # - Hash: equality conditions `{ name: "John" }` → `[["name", "=", "John"]]`
+  # - String: parsed condition `"age > 18"` → `[["age", ">", 18]]`
+  # - Array of strings: `["age > 18", "active = true"]`
+  # - Array of arrays: raw Odoo domain (passthrough)
+  #
+  module DomainBuilder
+    CONDITION_PATTERN = /\A(\w+)\s*(=|!=|<>|<=|>=|<|>|like|ilike|=like|=ilike)\s*(.+)\z/i
+
+    module_function
+
+    def build(conditions, attrs = {})
+      return hash_to_domain(attrs) if attrs.any?
+      return [] if conditions.nil?
+
+      case conditions
+      when String then [parse_string_condition(conditions)]
+      when Hash then hash_to_domain(conditions)
+      when Array then array_to_domain(conditions)
+      else raise ArgumentError, "Invalid conditions: #{conditions.class}"
+      end
+    end
+
+    def hash_to_domain(hash)
+      hash.map { |k, v| [k.to_s, "=", v] }
+    end
+
+    def array_to_domain(arr)
+      return [] if arr.empty?
+      return arr.map { |s| parse_string_condition(s) } if arr.first.is_a?(String)
+
+      arr
+    end
+
+    def parse_string_condition(str)
+      match = str.strip.match(CONDITION_PATTERN)
+      raise ArgumentError, "Invalid condition: '#{str}'" unless match
+
+      field = match[1]
+      operator = match[2] == "<>" ? "!=" : match[2].downcase
+      value = parse_value(match[3].strip)
+
+      [field, operator, value]
+    end
+
+    def parse_value(str)
+      case str
+      when /\A["'](.*)["']\z/ then ::Regexp.last_match(1)
+      when /\Atrue\z/i then true
+      when /\Afalse\z/i then false
+      when /\A-?\d+\z/ then str.to_i
+      when /\A-?\d+\.\d+\z/ then str.to_f
+      else str
+      end
+    end
+  end
+end

data/lib/rodoo/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rodoo
+  class Error < StandardError
+    attr_reader :original_error
+
+    def initialize(message = nil, original_error: nil)
+      @original_error = original_error
+      super(message)
+    end
+  end
+
+  class ConfigurationError < Error; end
+  class ConnectionError < Error; end
+  class TimeoutError < ConnectionError; end
+
+  class APIError < Error
+    attr_reader :code, :data
+
+    def initialize(message = nil, code: nil, data: nil, **kwargs)
+      @code = code
+      @data = data
+      super(message, **kwargs)
+    end
+  end
+
+  class AuthenticationError < APIError; end
+  class NotFoundError < APIError; end
+  class ValidationError < APIError; end
+  class AccessDeniedError < APIError; end
+end