attio-ruby 0.1.0 → 0.1.2

data/lib/attio/resources/deal.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require_relative "typed_record"
+
+module Attio
+  # Represents a Deal record in Attio
+  #
+  # @example Create a deal
+  #   deal = Attio::Deal.create(
+  #     name: "Enterprise Deal",
+  #     value: 50000,
+  #     stage: "In Progress"
+  #   )
+  #
+  # @example Find deals by status
+  #   open_deals = Attio::Deal.find_by(status: "open")
+  #   won_deals = Attio::Deal.find_by(status: "won")
+  #
+  # @example Find high-value deals
+  #   big_deals = Attio::Deal.find_by_value_range(min: 100000)
+  #
+  # @example Update deal status
+  #   deal.update_status("won")
+  #
+  class Deal < TypedRecord
+    object_type "deals"
+
+    class << self
+      # Create a deal with a simplified interface
+      # @param attributes [Hash] Deal attributes
+      # @option attributes [String] :name Deal name (recommended)
+      # @option attributes [Numeric] :value Deal value (recommended)
+      # @option attributes [String] :stage Deal stage (recommended) - defaults: "Lead", "In Progress", "Won 🎉", "Lost"
+      # @option attributes [String] :status Deal status (alias for stage)
+      # @option attributes [String] :owner Owner email or workspace member (recommended)
+      # @option attributes [Array<String>] :associated_people Email addresses of associated people
+      # @option attributes [Array<String>] :associated_company Domains of associated companies
+      # @option attributes [Hash] :values Raw values hash (for advanced use)
+      def create(name:, value: nil, stage: nil, status: nil, owner: nil,
+                 associated_people: nil, associated_company: nil, values: {}, **opts)
+        # Name is required and simple
+        values[:name] = name if name && !values[:name]
+        
+        # Add optional fields
+        values[:value] = value if value && !values[:value]
+        
+        # Handle stage vs status - API uses "stage" but we support both
+        if (stage || status) && !values[:stage]
+          values[:stage] = stage || status
+        end
+        
+        
+        # Handle owner - can be email address or workspace member reference
+        if owner && !values[:owner]
+          values[:owner] = owner
+        end
+        
+        # Handle associated people - convert email array to proper format
+        if associated_people && !values[:associated_people]
+          values[:associated_people] = associated_people.map do |email|
+            {
+              target_object: "people",
+              email_addresses: [
+                { email_address: email }
+              ]
+            }
+          end
+        end
+        
+        # Handle associated company - convert domain array to proper format
+        if associated_company && !values[:associated_company]
+          # associated_company can be array of domains or single domain
+          domains = associated_company.is_a?(Array) ? associated_company : [associated_company]
+          values[:associated_company] = {
+            target_object: "companies",
+            domains: domains.map { |domain| { domain: domain } }
+          }
+        end
+        
+        super(values: values, **opts)
+      end
+
+      # Find deals by stage names
+      # @param stage_names [Array<String>] Array of stage names to filter by
+      # @return [Attio::ListObject] List of matching deals
+      def in_stage(stage_names:, **opts)
+        # If only one stage, use simple equality
+        if stage_names.length == 1
+          filter = { stage: stage_names.first }
+        else
+          # Multiple stages need $or operator
+          filter = {
+            "$or": stage_names.map { |stage| { stage: stage } }
+          }
+        end
+        
+        list(**opts.merge(params: {filter: filter}))
+      end
+
+      # Find won deals using configured statuses
+      # @return [Attio::ListObject] List of won deals
+      def won(**opts)
+        in_stage(stage_names: Attio.configuration.won_statuses, **opts)
+      end
+
+      # Find lost deals using configured statuses
+      # @return [Attio::ListObject] List of lost deals
+      def lost(**opts)
+        in_stage(stage_names: Attio.configuration.lost_statuses, **opts)
+      end
+
+      # Find open deals (Lead + In Progress) using configured statuses
+      # @return [Attio::ListObject] List of open deals
+      def open_deals(**opts)
+        all_open_statuses = Attio.configuration.open_statuses + Attio.configuration.in_progress_statuses
+        in_stage(stage_names: all_open_statuses, **opts)
+      end
+
+      # Find deals within a value range
+      # @param min [Numeric] Minimum value (optional)
+      # @param max [Numeric] Maximum value (optional)
+      # @return [Attio::ListObject] List of matching deals
+      def find_by_value_range(min: nil, max: nil, **opts)
+        filters = []
+        filters << {value: {"$gte": min}} if min
+        filters << {value: {"$lte": max}} if max
+        
+        filter = if filters.length == 1
+          filters.first
+        elsif filters.length > 1
+          {"$and": filters}
+        else
+          {}
+        end
+        
+        list(**opts.merge(params: {filter: filter}))
+      end
+
+      # # Find deals closing soon (requires close_date attribute)
+      # # @param days [Integer] Number of days from today
+      # # @return [Attio::ListObject] List of deals closing soon
+      # def closing_soon(days: 30, **opts)
+      #   today = Date.today
+      #   end_date = today + days
+      #   
+      #   list(**opts.merge(params: {
+      #     filter: {
+      #       "$and": [
+      #         {close_date: {"$gte": today.iso8601}},
+      #         {close_date: {"$lte": end_date.iso8601}},
+      #         {stage: {"$ne": "Won 🎉"}},
+      #         {stage: {"$ne": "Lost"}}
+      #       ]
+      #     }
+      #   }))
+      # end
+
+      # Find deals by owner
+      # @param owner_id [String] The workspace member ID
+      # @return [Attio::ListObject] List of deals owned by the member
+      def find_by_owner(owner_id, **opts)
+        list(**opts.merge(params: {
+          filter: {
+            owner: {
+              target_object: "workspace_members",
+              target_record_id: owner_id
+            }
+          }
+        }))
+      end
+      
+      private
+      
+      # Build filter for status field (maps to stage)
+      def filter_by_status(value)
+        { stage: value }
+      end
+    end
+
+    # Get the deal name
+    # @return [String, nil] The deal name
+    def name
+      self[:name]
+    end
+
+    # Get the deal value
+    # @return [Numeric, nil] The deal value
+    def value
+      self[:value]
+    end
+
+    # Get the deal stage (API uses "stage" but we provide status for compatibility)
+    # @return [String, nil] The deal stage
+    def stage
+      self[:stage]
+    end
+    
+    # Alias for stage (for compatibility)
+    # @return [String, nil] The deal stage
+    def status
+      self[:stage]
+    end
+
+    # # Get the close date (if attribute exists)
+    # # @return [String, nil] The close date
+    # def close_date
+    #   self[:close_date]
+    # end
+
+    # # Get the probability (if attribute exists)
+    # # @return [Numeric, nil] The win probability
+    # def probability
+    #   self[:probability]
+    # end
+
+    # Get the owner reference
+    # @return [Hash, nil] The owner reference
+    def owner
+      self[:owner]
+    end
+
+    # Get the company reference
+    # @return [Hash, nil] The company reference
+    def company
+      self[:company]
+    end
+
+    # Update the deal stage
+    # @param new_stage [String] The new stage
+    # @return [Attio::Deal] The updated deal
+    def update_stage(new_stage, **opts)
+      self.class.update(id, values: {stage: new_stage}, **opts)
+    end
+    
+    # Alias for update_stage (for compatibility)
+    # @param new_status [String] The new status/stage
+    # @return [Attio::Deal] The updated deal
+    def update_status(new_status, **opts)
+      update_stage(new_status, **opts)
+    end
+
+    # # Update the deal probability (if attribute exists)
+    # # @param new_probability [Numeric] The new probability (0-100)
+    # # @return [Attio::Deal] The updated deal
+    # def update_probability(new_probability, **opts)
+    #   self.class.update(id, values: {probability: new_probability}, **opts)
+    # end
+
+    # Update the deal value
+    # @param new_value [Numeric] The new value
+    # @return [Attio::Deal] The updated deal
+    def update_value(new_value, **opts)
+      self.class.update(id, values: {value: new_value}, **opts)
+    end
+
+    # Get the associated company record
+    # @return [Attio::Company, nil] The company record if associated
+    def company_record(**opts)
+      return nil unless company
+      
+      company_id = company.is_a?(Hash) ? company["target_record_id"] : company
+      Company.retrieve(company_id, **opts) if company_id
+    end
+
+    # Get the owner workspace member record
+    # @return [Attio::WorkspaceMember, nil] The owner record if assigned
+    def owner_record(**opts)
+      return nil unless owner
+      
+      owner_id = if owner.is_a?(Hash)
+        owner["referenced_actor_id"] || owner["target_record_id"]
+      else
+        owner
+      end
+      WorkspaceMember.retrieve(owner_id, **opts) if owner_id
+    end
+
+    # # Calculate expected revenue (value * probability / 100)
+    # # @return [Numeric, nil] The expected revenue
+    # def expected_revenue
+    #   return nil unless value && probability
+    #   (value * probability / 100.0).round(2)
+    # end
+
+    # Get the current status title
+    # @return [String, nil] The current status title
+    def current_status
+      return nil unless stage
+      
+      if stage.is_a?(Hash)
+        stage.dig("status", "title")
+      else
+        stage
+      end
+    end
+
+    # Get the timestamp when the status changed
+    # @return [Time, nil] The timestamp when status changed
+    def status_changed_at
+      return nil unless stage
+      
+      if stage.is_a?(Hash) && stage["active_from"]
+        Time.parse(stage["active_from"])
+      else
+        nil
+      end
+    end
+
+    # Check if the deal is open
+    # @return [Boolean] True if the deal is open
+    def open?
+      return false unless current_status
+      
+      all_open_statuses = Attio.configuration.open_statuses + Attio.configuration.in_progress_statuses
+      all_open_statuses.include?(current_status)
+    end
+
+    # Check if the deal is won
+    # @return [Boolean] True if the deal is won
+    def won?
+      return false unless current_status
+      
+      Attio.configuration.won_statuses.include?(current_status)
+    end
+
+    # Check if the deal is lost
+    # @return [Boolean] True if the deal is lost
+    def lost?
+      return false unless current_status
+      
+      Attio.configuration.lost_statuses.include?(current_status)
+    end
+
+    # Get the timestamp when the deal was won
+    # @return [Time, nil] The timestamp when deal was won, or nil if not won
+    def won_at
+      won? ? status_changed_at : nil
+    end
+
+    # Get the timestamp when the deal was closed (won or lost)
+    # @return [Time, nil] The timestamp when deal was closed, or nil if still open
+    def closed_at
+      (won? || lost?) ? status_changed_at : nil
+    end
+
+    # # Check if the deal is overdue
+    # # @return [Boolean] True if close date has passed and deal is still open
+    # def overdue?
+    #   return false unless close_date && open?
+    #   Date.parse(close_date) < Date.today
+    # end
+  end
+
+  # Alias for Deal (plural form)
+  # @example
+  #   Attio::Deals.create(name: "New Deal", value: 10000)
+  Deals = Deal
+end

data/lib/attio/resources/meta.rb

@@ -23,47 +23,78 @@ module Attio
       alias_method :current, :identify
     end
 
-    # Define attribute accessors
-    attr_attio :workspace, :token, :actor
+    # Build workspace object from flat attributes
+    def workspace
+      return nil unless self[:workspace_id]
+      
+      {
+        id: self[:workspace_id],
+        name: self[:workspace_name],
+        slug: self[:workspace_slug],
+        logo_url: self[:workspace_logo_url]
+      }.compact
+    end
+    
+    # Build token object from flat attributes
+    def token
+      return nil unless self[:client_id]
+      
+      {
+        id: self[:client_id],
+        type: self[:token_type] || "Bearer",
+        scope: self[:scope]
+      }.compact
+    end
+    
+    # Build actor object from flat attributes
+    def actor
+      return nil unless self[:authorized_by_workspace_member_id]
+      
+      {
+        type: "workspace-member",
+        id: self[:authorized_by_workspace_member_id]
+      }
+    end
 
     # Convenience methods for workspace info
     def workspace_id
-      workspace&.dig(:id)
+      self[:workspace_id]
     end
 
     # Get the workspace name
     # @return [String, nil] The workspace name
     def workspace_name
-      workspace&.dig(:name)
+      self[:workspace_name]
     end
 
     # Get the workspace slug
     # @return [String, nil] The workspace slug
     def workspace_slug
-      workspace&.dig(:slug)
+      self[:workspace_slug]
     end
 
     # Convenience methods for token info
     def token_id
-      token&.dig(:id)
+      self[:client_id]
     end
 
     # Get the token name
-    # @return [String, nil] The token name
+    # @return [String, nil] The token name (not available in flat format)
     def token_name
-      token&.dig(:name)
+      nil
     end
 
     # Get the token type
     # @return [String, nil] The token type
     def token_type
-      token&.dig(:type)
+      self[:token_type]
     end
 
     # Get the token's OAuth scopes
     # @return [Array<String>] Array of scope strings
     def scopes
-      token&.dig(:scopes) || []
+      return [] unless self[:scope]
+      self[:scope].split(" ")
     end
 
     # Check if token has a specific scope
@@ -96,8 +127,6 @@ module Attio
       raise InvalidRequestError, "Meta information is read-only"
     end
 
-    private
-
     def to_h
       {
         workspace: workspace,
@@ -109,5 +138,7 @@ module Attio
     def inspect
       "#<#{self.class.name}:#{object_id} workspace=#{workspace_slug.inspect} token=#{token_name.inspect}>"
     end
+
+    private
   end
 end

data/lib/attio/resources/object.rb

@@ -45,11 +45,31 @@ module Attio
       Internal::Record.create(object: api_slug || id, values: values, **)
     end
 
-    # Find by API slug
+    # Find by attribute using Rails-style syntax
+    def self.find_by(**conditions)
+      # Extract any opts that aren't conditions
+      opts = {}
+      known_opts = [:api_key, :timeout, :idempotency_key]
+      known_opts.each do |opt|
+        opts[opt] = conditions.delete(opt) if conditions.key?(opt)
+      end
+      
+      # Currently only supports slug
+      if conditions.key?(:slug)
+        slug = conditions[:slug]
+        begin
+          retrieve(slug, **opts)
+        rescue NotFoundError
+          list(**opts).find { |obj| obj.api_slug == slug }
+        end
+      else
+        raise ArgumentError, "find_by only supports slug attribute for objects"
+      end
+    end
+    
+    # Find by API slug (deprecated - use find_by(slug: ...) instead)
     def self.find_by_slug(slug, **opts)
-      retrieve(slug, **opts)
-    rescue NotFoundError
-      list(**opts).find { |obj| obj.api_slug == slug }
+      find_by(slug: slug, **opts)
     end
 
     # Get standard objects

data/lib/attio/resources/person.rb

@@ -251,19 +251,6 @@ module Attio
         super(values: values, **opts)
       end
 
-      # Find people by email
-      # @param email [String] Email address to search for
-      def find_by_email(email, **opts)
-        list(**opts.merge(
-          filter: {
-            email_addresses: {
-              email_address: {
-                "$eq": email
-              }
-            }
-          }
-        )).first
-      end
 
       # Search people by query
       # @param query [String] Query to search for
@@ -280,11 +267,28 @@ module Attio
         ))
       end
 
-      # Find people by name
-      # @param name [String] Name to search for
-      def find_by_name(name, **opts)
-        results = search(name, **opts)
-        results.first
+      private
+      
+      # Build filter for email field
+      def filter_by_email(value)
+        {
+          email_addresses: {
+            email_address: {
+              "$eq": value
+            }
+          }
+        }
+      end
+      
+      # Build filter for name field (searches across first, last, and full name)
+      def filter_by_name(value)
+        {
+          "$or": [
+            {name: {first_name: {"$contains": value}}},
+            {name: {last_name: {"$contains": value}}},
+            {name: {full_name: {"$contains": value}}}
+          ]
+        }
       end
     end
   end

data/lib/attio/resources/typed_record.rb

@@ -61,12 +61,55 @@ module Attio
       end
 
       # Find by a specific attribute value
-      def find_by(attribute, value, **opts)
-        list(**opts.merge(params: {
-          filter: {
-            attribute => value
-          }
-        })).first
+      # Supports Rails-style hash syntax: find_by(name: "Test")
+      def find_by(**conditions)
+        raise ArgumentError, "find_by requires at least one condition" if conditions.empty?
+        
+        # Extract any opts that aren't conditions (like api_key)
+        opts = {}
+        known_opts = [:api_key, :timeout, :idempotency_key]
+        known_opts.each do |opt|
+          opts[opt] = conditions.delete(opt) if conditions.key?(opt)
+        end
+        
+        # Build filter from conditions
+        filters = []
+        search_query = nil
+        
+        conditions.each do |field, value|
+          # Check if there's a special filter method for this field
+          filter_method = "filter_by_#{field}"
+          if respond_to?(filter_method, true) # true = include private methods
+            result = send(filter_method, value)
+            # Check if this should be a search instead of a filter
+            if result == :use_search
+              search_query = value
+            else
+              filters << result
+            end
+          else
+            # Use the field as-is
+            filters << {field => value}
+          end
+        end
+        
+        # If we have a search query, use search instead of filter
+        if search_query
+          search(search_query, **opts).first
+        else
+          # Combine multiple filters with $and if needed
+          final_filter = if filters.length == 1
+            filters.first
+          elsif filters.length > 1
+            {"$and": filters}
+          else
+            {}
+          end
+          
+          list(**opts.merge(params: {
+            filter: final_filter
+          })).first
+        end
       end
     end
 

data/lib/attio/resources/workspace_member.rb

@@ -103,20 +103,33 @@ module Attio
       end
       alias_method :current, :me
 
-      # Find member by email
-      def find_by_email(email, **opts)
-        list(**opts).find { |member| member.email_address == email } ||
-          raise(NotFoundError, "Workspace member with email '#{email}' not found")
+      # Find member by attribute using Rails-style syntax
+      def find_by(**conditions)
+        # Extract any opts that aren't conditions
+        opts = {}
+        known_opts = [:api_key, :timeout, :idempotency_key]
+        known_opts.each do |opt|
+          opts[opt] = conditions.delete(opt) if conditions.key?(opt)
+        end
+        
+        # Currently only supports email
+        if conditions.key?(:email)
+          email = conditions[:email]
+          list(**opts).find { |member| member.email_address == email } ||
+            raise(NotFoundError, "Workspace member with email '#{email}' not found")
+        else
+          raise ArgumentError, "find_by only supports email attribute for workspace members"
+        end
       end
 
       # List active members only
-      def active(**)
-        list(**).select(&:active?)
+      def active(**opts)
+        list(**opts).select(&:active?)
       end
 
       # List admin members only
-      def admins(**)
-        list(**).select(&:admin?)
+      def admins(**opts)
+        list(**opts).select(&:admin?)
       end
 
       # This resource doesn't support creation, updates, or deletion

data/lib/attio/util/configuration.rb

@@ -22,6 +22,10 @@ module Attio
         ca_bundle_path
         verify_ssl_certs
         use_faraday
+        won_statuses
+        lost_statuses
+        open_statuses
+        in_progress_statuses
       ].freeze
 
       # All available configuration settings
@@ -38,7 +42,11 @@ module Attio
         debug: false,
         ca_bundle_path: nil,
         verify_ssl_certs: true,
-        use_faraday: true
+        use_faraday: true,
+        won_statuses: ["Won 🎉"].freeze,
+        lost_statuses: ["Lost"].freeze,
+        open_statuses: ["Lead"].freeze,
+        in_progress_statuses: ["In Progress"].freeze
       }.freeze
 
       attr_reader(*ALL_SETTINGS)
@@ -157,7 +165,9 @@ module Attio
 
       def reset_without_lock!
         DEFAULT_SETTINGS.each do |key, value|
-          instance_variable_set("@#{key}", value)
+          # For arrays, create a new copy to avoid frozen arrays
+          actual_value = value.is_a?(Array) ? value.dup : value
+          instance_variable_set("@#{key}", actual_value)
         end
         @api_key = nil
       end

data/lib/attio/version.rb

@@ -2,5 +2,5 @@
 
 module Attio
   # Current version of the Attio Ruby gem
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end