attio-ruby 0.1.0

data/lib/attio/resources/task.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "../api_resource"
+
+module Attio
+  # Represents a task in Attio
+  class Task < APIResource
+    # Don't use api_operations for list since we need custom handling
+    api_operations :create, :retrieve, :update, :delete
+
+    # API endpoint path for tasks
+    # @return [String] The API path
+    def self.resource_path
+      "tasks"
+    end
+
+    # Custom list implementation to handle query params properly
+    def self.list(**params)
+      # Query params should be part of the request, not opts
+      query_params = params.slice(:limit, :offset, :sort, :linked_object, :linked_record_id, :assignee, :is_completed)
+      opts = params.except(:limit, :offset, :sort, :linked_object, :linked_record_id, :assignee, :is_completed)
+
+      response = execute_request(:GET, resource_path, query_params, opts)
+      ListObject.new(response, self, params, opts)
+    end
+
+    class << self
+      alias_method :all, :list
+    end
+
+    # Override create to handle required content parameter
+    def self.create(content: nil, format: "plaintext", **params)
+      raise ArgumentError, "Content is required" if content.nil? || content.to_s.empty?
+
+      request_params = {
+        data: {
+          content: content,  # API expects 'content'
+          format: format,    # Format is required
+          is_completed: params[:is_completed] || false,
+          linked_records: params[:linked_records] || [],
+          assignees: params[:assignees] || []
+        }
+      }
+
+      # deadline_at must be present (null or valid date)
+      request_params[:data][:deadline_at] = params[:deadline_at]
+
+      # Remove the params that we've already included in request_params
+      opts = params.except(:content, :format, :deadline_at, :is_completed, :linked_records, :assignees)
+
+      response = execute_request(:POST, resource_path, request_params, opts)
+      new(response["data"] || response, opts)
+    end
+
+    # Override update to use PATCH with data wrapper
+    def self.update(id, **params)
+      validate_id!(id)
+
+      request_params = {
+        data: params.slice(:content, :format, :deadline_at, :is_completed, :linked_records, :assignees).compact
+      }
+
+      # Remove the params that we've already included in request_params
+      opts = params.except(:content, :format, :deadline_at, :is_completed, :linked_records, :assignees)
+
+      response = execute_request(:PATCH, "#{resource_path}/#{id}", request_params, opts)
+      new(response["data"] || response, opts)
+    end
+
+    # Define attribute accessors
+    attr_attio :content_plaintext, :is_completed, :linked_records, :assignees, :created_by_actor
+
+    # Parse deadline_at as Time
+    def deadline_at
+      value = @attributes[:deadline_at]
+      return nil if value.nil?
+
+      case value
+      when Time
+        value
+      when String
+        Time.parse(value)
+      else
+        value
+      end
+    end
+
+    # Convenience method to mark task as completed
+    def complete!(**opts)
+      raise InvalidRequestError, "Cannot complete a task without an ID" unless persisted?
+
+      params = {
+        data: {
+          is_completed: true
+        }
+      }
+
+      response = self.class.send(:execute_request, :PATCH, resource_path, params, opts)
+      update_from(response["data"] || response)
+      self
+    end
+
+    # Override save to handle task-specific attributes
+    def save(**opts)
+      raise InvalidRequestError, "Cannot save a task without an ID" unless persisted?
+
+      params = {
+        data: changed_attributes.slice(:content, :deadline_at, :is_completed, :linked_records, :assignees).compact
+      }
+
+      return self unless params[:data].any?
+
+      response = self.class.send(:execute_request, :PATCH, resource_path, params, opts)
+      update_from(response["data"] || response)
+      reset_changes!
+      self
+    end
+
+    # Override destroy to use the correct task ID
+    def destroy(**opts)
+      raise InvalidRequestError, "Cannot destroy a task without an ID" unless persisted?
+
+      task_id = extract_task_id
+      self.class.send(:execute_request, :DELETE, "#{self.class.resource_path}/#{task_id}", {}, opts)
+      @attributes.clear
+      @changed_attributes.clear
+      @id = nil
+      true
+    end
+
+    private
+
+    def extract_task_id
+      case id
+      when Hash
+        id[:task_id] || id["task_id"]
+      else
+        id
+      end
+    end
+
+    def resource_path
+      task_id = extract_task_id
+      "#{self.class.resource_path}/#{task_id}"
+    end
+  end
+end

data/lib/attio/resources/thread.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "../api_resource"
+
+module Attio
+  # Represents a comment thread in Attio (read-only)
+  class Thread < APIResource
+    # Threads only support list and retrieve (read-only resource)
+    # Don't use api_operations for list since we need custom handling
+    api_operations :retrieve
+
+    # API endpoint path for threads
+    # @return [String] The API path
+    def self.resource_path
+      "threads"
+    end
+
+    # Custom list implementation to handle query params properly
+    def self.list(**params)
+      # Query params should be part of the request, not opts
+      query_params = params.slice(:record_id, :object, :entry_id, :list, :limit, :offset)
+      opts = params.except(:record_id, :object, :entry_id, :list, :limit, :offset)
+
+      response = execute_request(:GET, resource_path, query_params, opts)
+      ListObject.new(response, self, params, opts)
+    end
+
+    class << self
+      alias_method :all, :list
+    end
+
+    # Define attribute accessors
+    attr_attio :comments
+
+    # Helper methods for working with comments
+    def comment_count
+      comments&.length || 0
+    end
+
+    def has_comments?
+      comment_count > 0
+    end
+
+    # Get the first comment in the thread
+    # @return [Hash, nil] First comment or nil if empty
+    def first_comment
+      comments&.first
+    end
+
+    # Get the last comment in the thread
+    # @return [Hash, nil] Last comment or nil if empty
+    def last_comment
+      comments&.last
+    end
+
+    # Threads are read-only
+    def immutable?
+      true
+    end
+
+    # Override save to raise error since threads are read-only
+    def save(**opts)
+      raise InvalidRequestError, "Threads are read-only and cannot be modified"
+    end
+
+    # Override destroy to raise error since threads are read-only
+    def destroy(**opts)
+      raise InvalidRequestError, "Threads are read-only and cannot be deleted"
+    end
+
+    private
+
+    def extract_thread_id
+      case id
+      when Hash
+        id[:thread_id] || id["thread_id"]
+      else
+        id
+      end
+    end
+
+    def resource_path
+      thread_id = extract_thread_id
+      "#{self.class.resource_path}/#{thread_id}"
+    end
+
+    def to_h
+      {
+        id: id,
+        comments: comments,
+        created_at: created_at&.iso8601
+      }.compact
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} id=#{id.inspect} comments=#{comment_count}>"
+    end
+  end
+end

data/lib/attio/resources/typed_record.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "../internal/record"
+
+module Attio
+  # Base class for type-specific record classes (e.g., Person, Company)
+  # Provides a more object-oriented interface for working with specific Attio objects
+  class TypedRecord < Internal::Record
+    class << self
+      # Define the object type for this class
+      # @param type [String] The Attio object type (e.g., "people", "companies")
+      def object_type(type = nil)
+        if type
+          @object_type = type
+        else
+          @object_type || raise(NotImplementedError, "#{self} must define object_type")
+        end
+      end
+
+      # Override list to automatically include object type
+      def list(**opts)
+        super(object: object_type, **opts)
+      end
+
+      # Override retrieve to automatically include object type
+      def retrieve(record_id, **opts)
+        super(object: object_type, record_id: record_id, **opts)
+      end
+
+      # Override create to automatically include object type
+      def create(values: {}, **opts)
+        super(object: object_type, values: values, **opts)
+      end
+
+      # Override update to automatically include object type
+      def update(record_id, values: {}, **opts)
+        super(object: object_type, record_id: record_id, data: {values: values}, **opts)
+      end
+
+      # Override delete to automatically include object type
+      def delete(record_id, **opts)
+        # The parent delete expects object in opts for records
+        simple_id = record_id.is_a?(Hash) ? record_id["record_id"] : record_id
+        execute_request(:DELETE, "objects/#{object_type}/records/#{simple_id}", {}, opts)
+        true
+      end
+
+      # Provide a more intuitive find method
+      def find(record_id, **opts)
+        retrieve(record_id, **opts)
+      end
+
+      # Provide a more intuitive all method
+      def all(**opts)
+        list(**opts)
+      end
+
+      # Search with a query string
+      def search(query, **opts)
+        list(**opts.merge(params: {q: query}))
+      end
+
+      # Find by a specific attribute value
+      def find_by(attribute, value, **opts)
+        list(**opts.merge(params: {
+          filter: {
+            attribute => value
+          }
+        })).first
+      end
+    end
+
+    # Override initialize to ensure object type is set
+    def initialize(attributes = {}, opts = {})
+      super
+      # Ensure the object type matches the class
+      if respond_to?(:object) && object != self.class.object_type
+        raise ArgumentError, "Object type mismatch: expected #{self.class.object_type}, got #{object}"
+      end
+    end
+
+    # Override save to include object type
+    def save(**opts)
+      raise InvalidRequestError, "Cannot save without an ID" unless persisted?
+      return self unless changed?
+
+      self.class.update(id, values: changed_attributes, **opts)
+    end
+
+    # Override destroy to include object type
+    def destroy(**opts)
+      raise InvalidRequestError, "Cannot destroy without an ID" unless persisted?
+
+      # Just call the parent destroy method which handles everything correctly
+      super
+    end
+  end
+end

data/lib/attio/resources/webhook.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative "../api_resource"
+require_relative "../webhook/signature_verifier"
+require_relative "../webhook/event"
+
+module Attio
+  # Represents a webhook configuration in Attio
+  class Webhook < APIResource
+    api_operations :list, :retrieve, :create, :update, :delete
+
+    # API endpoint path for webhooks
+    # @return [String] The API path
+    def self.resource_path
+      "webhooks"
+    end
+
+    # Event types
+    EVENTS = %w[
+      record.created
+      record.updated
+      record.deleted
+      list_entry.created
+      list_entry.deleted
+      note.created
+      note.deleted
+      task.created
+      task.updated
+      task.deleted
+      object.created
+      object.updated
+      attribute.created
+      attribute.updated
+      attribute.archived
+    ].freeze
+
+    # Define known attributes with proper accessors
+    attr_attio :target_url, :subscriptions, :status
+
+    # Read-only attributes
+    attr_reader :secret, :last_event_at, :created_by_actor
+    attr_accessor :active
+
+    # Alias url to target_url for convenience
+    alias_method :url, :target_url
+    alias_method :url=, :target_url=
+
+    def initialize(attributes = {}, opts = {})
+      super
+      normalized_attrs = normalize_attributes(attributes)
+      @secret = normalized_attrs[:secret]
+      @last_event_at = parse_timestamp(normalized_attrs[:last_event_at])
+      @created_by_actor = normalized_attrs[:created_by_actor]
+
+      # Map status to active for convenience
+      if status == "active"
+        instance_variable_set(:@active, true)
+      elsif status == "paused"
+        instance_variable_set(:@active, false)
+      end
+    end
+
+    def resource_path
+      raise InvalidRequestError, "Cannot generate path without an ID" unless persisted?
+      webhook_id = Util::IdExtractor.extract_for_resource(id, :webhook)
+      "#{self.class.resource_path}/#{webhook_id}"
+    end
+
+    # Override save to handle nested ID
+    def save(**)
+      raise InvalidRequestError, "Cannot save a webhook without an ID" unless persisted?
+      return self unless changed?
+
+      webhook_id = Util::IdExtractor.extract_for_resource(id, :webhook)
+      self.class.update(webhook_id, changed_attributes, **)
+    end
+
+    # Override destroy to handle nested ID
+    def destroy(**opts)
+      raise InvalidRequestError, "Cannot destroy a webhook without an ID" unless persisted?
+
+      webhook_id = Util::IdExtractor.extract_for_resource(id, :webhook)
+      self.class.delete(webhook_id, **opts)
+      freeze
+      true
+    end
+
+    # Check if webhook is active
+    def active?
+      active == true
+    end
+
+    # Check if webhook is paused
+    def paused?
+      !active?
+    end
+
+    # Pause the webhook
+    def pause(**opts)
+      self.active = false
+      save(**opts)
+    end
+
+    # Resume the webhook
+    def resume(**opts)
+      self.active = true
+      save(**opts)
+    end
+    alias_method :activate, :resume
+
+    # Test the webhook with a sample payload
+    def test(**opts)
+      raise InvalidRequestError, "Cannot test a webhook without an ID" unless persisted?
+
+      self.class.send(:execute_request, :POST, "#{resource_path}/test", {}, opts)
+      true
+    end
+
+    # Get recent deliveries for this webhook
+    def deliveries(params = {}, **opts)
+      raise InvalidRequestError, "Cannot get deliveries for a webhook without an ID" unless persisted?
+
+      response = self.class.send(:execute_request, :GET, "#{resource_path}/deliveries", params, opts)
+      response[:data] || []
+    end
+
+    # Convert webhook to hash representation
+    # @return [Hash] Webhook data as a hash
+    def to_h
+      super.merge(
+        target_url: target_url,
+        subscriptions: subscriptions,
+        status: status,
+        secret: secret,
+        last_event_at: last_event_at&.iso8601,
+        created_by_actor: created_by_actor
+      ).compact
+    end
+
+    class << self
+      # Override create to handle keyword arguments
+      def create(**kwargs)
+        opts = {}
+        opts[:api_key] = kwargs.delete(:api_key) if kwargs.key?(:api_key)
+        prepared_params = prepare_params_for_create(kwargs)
+        response = execute_request(:POST, resource_path, prepared_params, opts)
+        new(response["data"] || response, opts)
+      end
+
+      # Override retrieve to handle hash IDs
+      def retrieve(id, **opts)
+        webhook_id = Util::IdExtractor.extract_for_resource(id, :webhook)
+        response = execute_request(:GET, "#{resource_path}/#{webhook_id}", {}, opts)
+        new(response["data"] || response, opts)
+      end
+
+      # Override delete to handle hash IDs
+      def delete(id, **opts)
+        webhook_id = Util::IdExtractor.extract_for_resource(id, :webhook)
+        execute_request(:DELETE, "#{resource_path}/#{webhook_id}", {}, opts)
+        true
+      end
+
+      # Override create to handle validation
+      def prepare_params_for_create(params)
+        # Handle both url and target_url parameters for convenience
+        target_url = params[:target_url] || params["target_url"] || params[:url] || params["url"]
+        validate_target_url!(target_url)
+        subscriptions = params[:subscriptions] || params["subscriptions"]
+        validate_subscriptions!(subscriptions)
+
+        {
+          data: {
+            target_url: target_url,
+            subscriptions: Array(subscriptions).map do |sub|
+              # Ensure each subscription has a filter
+              sub = sub.is_a?(Hash) ? sub : {"event_type" => sub}
+              sub["filter"] ||= {"$and" => []}  # Default empty filter
+              sub
+            end
+          }
+        }
+      end
+
+      # Override update params preparation
+      def prepare_params_for_update(params)
+        {
+          data: params
+        }
+      end
+
+      private
+
+      def validate_target_url!(url)
+        raise BadRequestError, "target_url or url is required" if url.nil? || url.empty?
+
+        uri = URI.parse(url)
+        unless uri.scheme == "https"
+          raise BadRequestError, "Webhook target_url must use HTTPS"
+        end
+      rescue URI::InvalidURIError
+        raise BadRequestError, "Invalid webhook target_url"
+      end
+
+      def validate_subscriptions!(subscriptions)
+        raise ArgumentError, "subscriptions are required" if subscriptions.nil? || subscriptions.empty?
+        raise ArgumentError, "subscriptions must be an array" unless subscriptions.is_a?(Array)
+
+        subscriptions.each do |sub|
+          event_type = if sub.is_a?(Hash)
+            sub[:event_type] || sub["event_type"]
+          else
+            sub  # sub is a string representing the event type
+          end
+          raise ArgumentError, "Each subscription must have an event_type" unless event_type
+        end
+      end
+    end
+
+    # Constants to match expected API
+    SignatureVerifier = WebhookUtils::SignatureVerifier
+    Event = WebhookUtils::Event
+  end
+end

data/lib/attio/resources/workspace_member.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "../api_resource"
+
+module Attio
+  # Represents a workspace member in Attio (read-only)
+  class WorkspaceMember < APIResource
+    api_operations :list, :retrieve
+
+    # API endpoint path for workspace members
+    # @return [String] The API path
+    def self.resource_path
+      "workspace_members"
+    end
+
+    # Read-only attributes - workspace members are immutable via API
+    attr_reader :email_address, :first_name, :last_name, :avatar_url,
+      :access_level, :status, :invited_at, :last_accessed_at
+
+    def initialize(attributes = {}, opts = {})
+      super
+      normalized_attrs = normalize_attributes(attributes)
+      @email_address = normalized_attrs[:email_address]
+      @first_name = normalized_attrs[:first_name]
+      @last_name = normalized_attrs[:last_name]
+      @avatar_url = normalized_attrs[:avatar_url]
+      @access_level = normalized_attrs[:access_level]
+      @status = normalized_attrs[:status]
+      @invited_at = parse_timestamp(normalized_attrs[:invited_at])
+      @last_accessed_at = parse_timestamp(normalized_attrs[:last_accessed_at])
+    end
+
+    # Get full name
+    def full_name
+      [first_name, last_name].compact.join(" ")
+    end
+
+    # Check if member is active
+    def active?
+      status == "active"
+    end
+
+    # Check if member is invited
+    def invited?
+      status == "invited"
+    end
+
+    # Check if member is deactivated
+    def deactivated?
+      status == "deactivated"
+    end
+
+    # Check if member is admin
+    def admin?
+      access_level == "admin"
+    end
+
+    # Check if member is standard user
+    def standard?
+      access_level == "standard"
+    end
+
+    # Workspace members cannot be modified via API
+    def save(*)
+      raise NotImplementedError, "Workspace members cannot be updated via API"
+    end
+
+    def update(*)
+      raise NotImplementedError, "Workspace members cannot be updated via API"
+    end
+
+    def destroy(*)
+      raise NotImplementedError, "Workspace members cannot be deleted via API"
+    end
+
+    # Convert workspace member to hash representation
+    # @return [Hash] Member data as a hash
+    def to_h
+      super.merge(
+        email_address: email_address,
+        first_name: first_name,
+        last_name: last_name,
+        avatar_url: avatar_url,
+        access_level: access_level,
+        status: status,
+        invited_at: invited_at&.iso8601,
+        last_accessed_at: last_accessed_at&.iso8601
+      ).compact
+    end
+
+    class << self
+      # Get the current user (the API key owner)
+      def me(**opts)
+        # The /v2/workspace_members/me endpoint doesn't exist, use /v2/self instead
+        # and then fetch the workspace member details
+        self_response = execute_request(:GET, "self", {}, opts)
+        member_id = self_response[:authorized_by_workspace_member_id]
+        self_response[:workspace_id]
+
+        # Now fetch the actual workspace member
+        members = list(**opts)
+        members.find { |m| m.id[:workspace_member_id] == member_id }
+      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")
+      end
+
+      # List active members only
+      def active(**)
+        list(**).select(&:active?)
+      end
+
+      # List admin members only
+      def admins(**)
+        list(**).select(&:admin?)
+      end
+
+      # This resource doesn't support creation, updates, or deletion
+      def create(*)
+        raise NotImplementedError, "Workspace members cannot be created via API"
+      end
+
+      def update(*)
+        raise NotImplementedError, "Workspace members cannot be updated via API"
+      end
+
+      def delete(*)
+        raise NotImplementedError, "Workspace members cannot be deleted via API"
+      end
+    end
+  end
+end