attio-ruby 0.1.0 → 0.1.1

data/examples/deals.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "attio"
+
+# This example demonstrates working with Deals in Attio
+
+# Setup
+Attio.api_key = ENV["ATTIO_API_KEY"] || raise("Please set ATTIO_API_KEY")
+owner_email = ENV["ATTIO_TEST_USER_EMAIL"] || "sales@example.com"
+
+puts "=== Creating Deals ==="
+
+# Create a basic deal
+deal = Attio::Deal.create(
+  name: "Enterprise Software Deal",
+  value: 50000,
+  stage: "In Progress",
+  owner: owner_email
+)
+
+puts "Created deal: #{deal.name}"
+puts "Value: $#{deal.value["currency_value"]}"
+puts "Stage: #{deal.stage["status"]["title"]}"
+
+# Create a deal with associations
+partnership_deal = Attio::Deal.create(
+  name: "Partnership Deal",
+  value: 100000,
+  stage: "Lead",
+  owner: owner_email,
+  associated_people: ["partner@example.com", "contact@partner.com"],
+  associated_company: ["partner.com"]
+)
+
+puts "\nCreated partnership deal with associations"
+
+puts "\n=== Searching Deals ==="
+
+# Find high-value deals
+big_deals = Attio::Deal.find_by_value_range(min: 75000)
+puts "Found #{big_deals.count} deals worth $75k+"
+
+# Find deals in a value range
+mid_deals = Attio::Deal.find_by_value_range(min: 25000, max: 75000)
+puts "Found #{mid_deals.count} deals worth $25k-$75k"
+
+# Find deals by stage
+in_progress = Attio::Deal.find_by(stage: "In Progress")
+puts "Found #{in_progress ? 1 : 0} deals in progress"
+
+puts "\n=== Updating Deals ==="
+
+# Update deal stage
+deal.update_stage("Won 🎉")
+puts "Updated deal stage to: Won 🎉"
+
+# Update deal value
+deal.update_value(75000)
+puts "Updated deal value to: $75,000"
+
+# Check deal status
+puts "\nDeal status checks:"
+puts "Is open? #{deal.open?}"
+puts "Is won? #{deal.won?}"
+puts "Is lost? #{deal.lost?}"
+
+puts "\n=== Deal Pipeline Analysis ==="
+
+# List all deals and analyze by stage
+all_deals = Attio::Deal.list(params: { limit: 50 })
+stage_counts = Hash.new(0)
+
+all_deals.each do |d|
+  stage_title = d.stage.dig("status", "title") if d.stage.is_a?(Hash)
+  stage_counts[stage_title || "Unknown"] += 1
+end
+
+puts "Pipeline breakdown:"
+stage_counts.each do |stage, count|
+  puts "  #{stage}: #{count} deals"
+end
+
+# Calculate total pipeline value
+total_value = all_deals.sum do |d|
+  d.value.is_a?(Hash) ? (d.value["currency_value"] || 0) : 0
+end
+
+puts "\nTotal pipeline value: $#{total_value}"
+
+puts "\n=== Working with Deal Relationships ==="
+
+# Get associated company (if available)
+if deal.company
+  begin
+    company = deal.company_record
+    puts "Deal is associated with: #{company.name}" if company
+  rescue => e
+    puts "Could not fetch company: #{e.message}"
+  end
+end
+
+puts "\n=== Cleanup ==="
+
+# Clean up test deals
+[deal, partnership_deal].each do |d|
+  d.destroy if d.persisted?
+  puts "Deleted deal: #{d.name}"
+end
+
+puts "\nDone!"

data/examples/oauth_flow.rb

@@ -223,22 +223,22 @@ class OAuthApp < Sinatra::Base
 
       # Test 3: List People Records
       begin
-        people = Attio::Record.list(object: "people", limit: 3)
+        people = Attio::Person.list(limit: 3)
         results[:people] = people.count
-        puts "✓ Record.list (people) successful (#{people.count} records)"
+        puts "✓ Person.list successful (#{people.count} records)"
       rescue => e
         errors[:people] = e.message
-        puts "✗ Record.list (people) failed: #{e.message}"
+        puts "✗ Person.list failed: #{e.message}"
       end
 
       # Test 4: List Companies Records
       begin
-        companies = Attio::Record.list(object: "companies", limit: 3)
+        companies = Attio::Company.list(limit: 3)
         results[:companies] = companies.count
-        puts "✓ Record.list (companies) successful (#{companies.count} records)"
+        puts "✓ Company.list successful (#{companies.count} records)"
       rescue => e
         errors[:companies] = e.message
-        puts "✗ Record.list (companies) failed: #{e.message}"
+        puts "✗ Company.list failed: #{e.message}"
       end
 
       # Test 5: List Lists
@@ -399,23 +399,17 @@ class OAuthApp < Sinatra::Base
       # Test 3: Create a Person
       person = nil
       begin
-        person = Attio::Record.create(
-          object: "people",
-          values: {
-            name: [{
-              first_name: "OAuth",
-              last_name: "Test #{Time.now.to_i}",
-              full_name: "OAuth Test #{Time.now.to_i}"
-            }],
-            email_addresses: ["oauth-#{Time.now.to_i}@example.com"]
-          }
+        person = Attio::Person.create(
+          first_name: "OAuth",
+          last_name: "Test #{Time.now.to_i}",
+          email: "oauth-#{Time.now.to_i}@example.com"
         )
         created_resources << {type: "person", id: person.id["record_id"]}
         results[:create_person] = "Created person ID: #{person.id["record_id"][0..10]}..."
-        puts "✓ Record.create (person) successful"
+        puts "✓ Person.create successful"
       rescue => e
         errors[:create_person] = e.message
-        puts "✗ Record.create failed: #{e.message}"
+        puts "✗ Person.create failed: #{e.message}"
       end
 
       # Test 4: Create a Note
@@ -425,15 +419,12 @@ class OAuthApp < Sinatra::Base
           puts "  person.id: #{person.id.inspect}"
           puts "  person.id['record_id']: #{person.id["record_id"].inspect}"
 
-          note_params = {
+          Attio::Note.create(
             parent_object: "people",
             parent_record_id: person.id["record_id"],
             content: "Test note created via OAuth at #{Time.now}",
             format: "plaintext"
-          }
-          puts "  note_params: #{note_params.inspect}"
-
-          Attio::Note.create(note_params)
+          )
           results[:create_note] = "Created note on person"
           puts "✓ Note.create successful"
         rescue => e
@@ -571,31 +562,23 @@ class OAuthApp < Sinatra::Base
       # Test 12: Update Operations
       if person
         begin
-          Attio::Record.update(
-            object: "people",
-            record_id: person.id["record_id"],
-            data: {
-              values: {
-                name: [{
-                  first_name: "OAuth",
-                  last_name: "Test Updated #{Time.now.to_i}",
-                  full_name: "OAuth Test Updated #{Time.now.to_i}"
-                }]
-              }
-            }
+          person.set_name(
+            first: "OAuth",
+            last: "Test Updated #{Time.now.to_i}"
           )
+          person.save
           results[:update_record] = "Updated person name"
-          puts "✓ Record.update successful"
+          puts "✓ Person.update successful"
         rescue => e
           errors[:update_record] = e.message
-          puts "✗ Record.update failed: #{e.message}"
+          puts "✗ Person.update failed: #{e.message}"
         end
       end
 
       # Test 13: Error Handling
       begin
         # Use a properly formatted UUID that doesn't exist
-        Attio::Record.retrieve(object: "people", record_id: "00000000-0000-0000-0000-000000000000")
+        Attio::Person.retrieve("00000000-0000-0000-0000-000000000000")
       rescue Attio::NotFoundError => e
         results[:error_handling] = "404 errors handled correctly"
         puts "✓ Error handling working correctly"
@@ -620,7 +603,7 @@ class OAuthApp < Sinatra::Base
         case resource[:type]
         when "person"
           # Need to retrieve the record first to call destroy on the instance
-          record = Attio::Record.retrieve(object: "people", record_id: resource[:id])
+          record = Attio::Person.retrieve(resource[:id])
           record.destroy
           cleanup_count += 1
         when "task"
@@ -729,16 +712,10 @@ class OAuthApp < Sinatra::Base
     begin
       # Create a test person first
       timestamp = Time.now.to_i
-      person = Attio::Record.create(
-        object: "people",
-        values: {
-          name: [{
-            first_name: "Note",
-            last_name: "Test#{timestamp}",
-            full_name: "Note Test#{timestamp}"
-          }],
-          email_addresses: ["note-test-#{timestamp}@example.com"]
-        }
+      person = Attio::Person.create(
+        first_name: "Note",
+        last_name: "Test#{timestamp}",
+        email: "note-test-#{timestamp}@example.com"
       )
 
       result_html = "<h1>Note Creation Test</h1>"

data/examples/typed_records_example.rb

@@ -73,10 +73,12 @@ puts <<~NEW
   puts person.email      # => "john@example.com"
   puts person.phone      # => "+12125551234"
 
-  # Searching is simpler
+  # Searching is simpler with Rails-style find_by
   people = Attio::Person.search("john")
-  people = Attio::Person.find_by_email("john@example.com")
-  people = Attio::Person.find_by_name("John Doe")
+  person = Attio::Person.find_by(email: "john@example.com")
+  person = Attio::Person.find_by(name: "John Doe")
+  # Can combine multiple conditions
+  person = Attio::Person.find_by(email: "john@example.com", job_title: "CEO")
 
   # Creating a company (no more array wrapping for simple names!)
   company = Attio::Company.create(
@@ -103,10 +105,11 @@ puts <<~NEW
   # Find company's team members
   team = company.team_members
 
-  # Find companies by various criteria
-  company = Attio::Company.find_by_domain("acme.com")
-  company = Attio::Company.find_by_name("Acme")
-  large_companies = Attio::Company.find_by_size(100)  # 100+ employees
+  # Find companies by various criteria using Rails-style find_by
+  company = Attio::Company.find_by(domain: "acme.com")
+  company = Attio::Company.find_by(name: "Acme")
+  # Can combine multiple conditions
+  tech_giant = Attio::Company.find_by(domain: "tech.com", employee_count: "1000+")
 NEW
 
 # Working example (if API key is set)

data/lib/attio/internal/record.rb

@@ -42,7 +42,9 @@ module Attio
           validate_object_identifier!(object)
 
           # Extract query parameters from opts
-          query_params = build_query_params(opts)
+          # Handle both opts[:params] (from find_by) and direct opts (from other callers)
+          params = opts[:params] || opts
+          query_params = build_query_params(params)
 
           response = execute_request(:POST, "#{resource_path}/#{object}/records/query", query_params, opts)
 
@@ -80,7 +82,7 @@ module Attio
 
           # Ensure object info is included
           record_data = response["data"] || {}
-          record_data[:object_api_slug] ||= object if record_data.is_a?(Hash)
+          record_data["object_api_slug"] ||= object if record_data.is_a?(Hash)
 
           new(record_data, opts)
         end
@@ -96,7 +98,7 @@ module Attio
           response = execute_request(:GET, "#{resource_path}/#{object}/records/#{simple_record_id}", {}, opts)
 
           record_data = response["data"] || {}
-          record_data[:object_api_slug] ||= object
+          record_data["object_api_slug"] ||= object if record_data.is_a?(Hash)
 
           new(record_data, opts)
         end
@@ -120,7 +122,7 @@ module Attio
           response = execute_request(:PUT, "#{resource_path}/#{object}/records/#{simple_record_id}", request_params, opts)
 
           record_data = response["data"] || {}
-          record_data[:object_api_slug] ||= object
+          record_data["object_api_slug"] ||= object if record_data.is_a?(Hash)
 
           new(record_data, opts)
         end
@@ -188,7 +190,7 @@ module Attio
 
         # Attributes that should be sent as simple arrays of strings or simple values
         SIMPLE_ARRAY_ATTRIBUTES = %w[email_addresses domains].freeze
-        SIMPLE_VALUE_ATTRIBUTES = %w[description linkedin job_title employee_count].freeze
+        SIMPLE_VALUE_ATTRIBUTES = %w[description linkedin job_title employee_count value stage status close_date probability owner].freeze
         # Attributes that are arrays of objects and should be sent as-is
         OBJECT_ARRAY_ATTRIBUTES = %w[phone_numbers primary_location company].freeze
 
@@ -338,9 +340,16 @@ module Attio
         when Hash
           if value_data.key?(:value) || value_data.key?("value")
             value_data[:value] || value_data["value"]
-          elsif value_data.key?(:target_object) || value_data.key?("target_object")
-            # Reference value
-            value_data[:target_object] || value_data["target_object"]
+          elsif value_data.key?(:target_object) || value_data.key?("target_object") ||
+                value_data.key?(:referenced_actor_type) || value_data.key?("referenced_actor_type")
+            # Reference value - return the full reference object
+            value_data
+          elsif value_data.key?(:currency_value) || value_data.key?("currency_value")
+            # Currency value - return the full object to preserve currency info
+            value_data
+          elsif value_data.key?(:status) || value_data.key?("status")
+            # Status value - return the full object to preserve status info
+            value_data
           else
             value_data
           end

data/lib/attio/resources/company.rb

@@ -141,7 +141,10 @@ module Attio
       company_id = id.is_a?(Hash) ? id["record_id"] : id
       Person.list(**opts.merge(params: {
         filter: {
-          company: {"$references": company_id}
+          company: {
+            target_object: "companies",
+            target_record_id: company_id
+          }
         }
       }))
     end
@@ -173,29 +176,6 @@ module Attio
         super(values: values, **opts)
       end
 
-      # Find a company by domain
-      # @param domain [String] Domain to search for
-      def find_by_domain(domain, **opts)
-        # Normalize domain
-        domain = domain.sub(/^https?:\/\//, "")
-
-        list(**opts.merge(
-          filter: {
-            domains: {
-              domain: {
-                "$eq": domain
-              }
-            }
-          }
-        )).first
-      end
-
-      # Find companies by name
-      # @param name [String] Name to search for
-      def find_by_name(name, **opts)
-        results = search(name, **opts)
-        results.first
-      end
 
       # Find companies by employee count range
       # @param min [Integer] Minimum employee count
@@ -216,6 +196,28 @@ module Attio
 
         list(**opts.merge(params: {filter: filter}))
       end
+      
+      private
+      
+      # Build filter for domain field
+      def filter_by_domain(value)
+        # Strip protocol if present
+        normalized_domain = value.sub(/^https?:\/\//, "")
+        {
+          domains: {
+            domain: {
+              "$eq": normalized_domain
+            }
+          }
+        }
+      end
+      
+      # Build filter for name field
+      def filter_by_name(value)
+        {
+          name: {"$contains": value}
+        }
+      end
     end
   end