attio-ruby 0.1.0

data/lib/attio/resources/entry.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "../api_resource"
+
+module Attio
+  # Represents an entry in an Attio list
+  # Entries link records to lists with custom attribute values
+  class Entry < APIResource
+    attr_reader :parent_record_id, :parent_object, :list_id
+    attr_accessor :entry_values
+
+    def initialize(attributes = {}, opts = {})
+      super
+
+      normalized_attrs = normalize_attributes(attributes)
+
+      # Extract specific entry attributes
+      @parent_record_id = normalized_attrs[:parent_record_id]
+      @parent_object = normalized_attrs[:parent_object]
+      @entry_values = normalized_attrs[:entry_values] || {}
+
+      # Extract list_id from nested ID structure
+      if normalized_attrs[:id].is_a?(Hash)
+        @list_id = normalized_attrs[:id][:list_id]
+      end
+    end
+
+    class << self
+      # API endpoint path for entries (nested under lists)
+      # @return [String] The API path
+      def resource_path
+        "lists"
+      end
+
+      # List entries for a list
+      def list(list: nil, **params)
+        validate_list_identifier!(list)
+
+        response = execute_request(:POST, "#{resource_path}/#{list}/entries/query", params, {})
+        APIResource::ListObject.new(response, self, params.merge(list: list), params)
+      end
+      alias_method :all, :list
+
+      # Create a new entry
+      def create(list: nil, parent_record_id: nil, parent_object: nil, entry_values: nil, **opts)
+        validate_list_identifier!(list)
+        validate_parent_params!(parent_record_id, parent_object)
+
+        request_params = {
+          data: {
+            parent_record_id: parent_record_id,
+            parent_object: parent_object,
+            entry_values: entry_values || {}
+          }
+        }
+
+        response = execute_request(:POST, "#{resource_path}/#{list}/entries", request_params, opts)
+        new(response["data"] || response, opts)
+      end
+
+      # Retrieve a specific entry
+      def retrieve(list: nil, entry_id: nil, **opts)
+        validate_list_identifier!(list)
+        validate_entry_id!(entry_id)
+
+        response = execute_request(:GET, "#{resource_path}/#{list}/entries/#{entry_id}", {}, opts)
+        new(response["data"] || response, opts)
+      end
+      alias_method :get, :retrieve
+      alias_method :find, :retrieve
+
+      # Update an entry
+      def update(list: nil, entry_id: nil, entry_values: nil, mode: nil, **opts)
+        validate_list_identifier!(list)
+        validate_entry_id!(entry_id)
+
+        request_params = {
+          data: {
+            entry_values: entry_values || {}
+          }
+        }
+
+        # Add mode parameter for append operations
+        if mode == "append"
+          request_params[:mode] = "append"
+        end
+
+        response = execute_request(:PATCH, "#{resource_path}/#{list}/entries/#{entry_id}", request_params, opts)
+        new(response["data"] || response, opts)
+      end
+
+      # Delete an entry
+      def delete(list: nil, entry_id: nil, **opts)
+        validate_list_identifier!(list)
+        validate_entry_id!(entry_id)
+
+        execute_request(:DELETE, "#{resource_path}/#{list}/entries/#{entry_id}", {}, opts)
+        true
+      end
+      alias_method :destroy, :delete
+
+      # Assert an entry by parent record
+      def assert_by_parent(list: nil, parent_record_id: nil, parent_object: nil, entry_values: nil, **opts)
+        validate_list_identifier!(list)
+        validate_parent_params!(parent_record_id, parent_object)
+
+        request_params = {
+          data: {
+            parent_record_id: parent_record_id,
+            parent_object: parent_object,
+            entry_values: entry_values || {}
+          }
+        }
+
+        response = execute_request(:PUT, "#{resource_path}/#{list}/entries", request_params, opts)
+        new(response["data"] || response, opts)
+      end
+
+      # List attribute values for an entry
+      def list_attribute_values(list: nil, entry_id: nil, attribute_id: nil, **opts)
+        validate_list_identifier!(list)
+        validate_entry_id!(entry_id)
+        raise ArgumentError, "Attribute ID is required" if attribute_id.nil? || attribute_id.to_s.empty?
+
+        response = execute_request(:GET, "#{resource_path}/#{list}/entries/#{entry_id}/attributes/#{attribute_id}/values", {}, opts)
+        response["data"] || []
+      end
+
+      private
+
+      def validate_list_identifier!(list)
+        raise ArgumentError, "List identifier is required" if list.nil? || list.to_s.empty?
+      end
+
+      def validate_entry_id!(entry_id)
+        raise ArgumentError, "Entry ID is required" if entry_id.nil? || entry_id.to_s.empty?
+      end
+
+      def validate_parent_params!(parent_record_id, parent_object)
+        if parent_record_id.nil? || parent_object.nil?
+          raise ArgumentError, "parent_record_id and parent_object are required"
+        end
+      end
+    end
+
+    # Instance methods
+
+    def save(**opts)
+      raise InvalidRequestError, "Cannot save an entry without an ID" unless persisted?
+      raise InvalidRequestError, "Cannot save without list context" unless list_id
+
+      # For Entry, we always save the full entry_values
+      params = {
+        data: {
+          entry_values: entry_values
+        }
+      }
+
+      response = self.class.send(:execute_request, :PATCH, resource_path, params, opts)
+      update_from(response[:data] || response)
+      reset_changes!
+      self
+    end
+
+    def destroy(**opts)
+      raise InvalidRequestError, "Cannot destroy an entry without an ID" unless persisted?
+      raise InvalidRequestError, "Cannot destroy without list context" unless list_id
+
+      entry_id = extract_entry_id
+      self.class.send(:execute_request, :DELETE, "lists/#{list_id}/entries/#{entry_id}", {}, opts)
+      @attributes.clear
+      @changed_attributes.clear
+      @id = nil
+      true
+    end
+
+    def resource_path
+      raise InvalidRequestError, "Cannot generate path without list context" unless list_id
+      entry_id = extract_entry_id
+      "lists/#{list_id}/entries/#{entry_id}"
+    end
+
+    private
+
+    def extract_entry_id
+      case id
+      when Hash
+        id[:entry_id] || id["entry_id"]
+      else
+        id
+      end
+    end
+
+    def to_h
+      {
+        id: id,
+        parent_record_id: parent_record_id,
+        parent_object: parent_object,
+        created_at: created_at&.iso8601,
+        entry_values: entry_values
+      }.compact
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} id=#{id.inspect} parent=#{parent_object}##{parent_record_id} values=#{entry_values.inspect}>"
+    end
+  end
+end

data/lib/attio/resources/list.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require_relative "../api_resource"
+
+module Attio
+  # Represents a list in Attio for organizing records
+  class List < APIResource
+    api_operations :list, :retrieve, :create, :update
+
+    # API endpoint path for lists
+    # @return [String] The API path
+    def self.resource_path
+      "lists"
+    end
+
+    # Define known attributes with proper accessors
+    attr_attio :name, :workspace_access
+
+    # Read-only attributes
+    attr_reader :api_slug, :attio_object_id, :object_api_slug,
+      :created_by_actor, :workspace_id, :parent_object, :filters
+
+    # Get the parent object as a string
+    def object
+      # parent_object is returned as an array from the API
+      return nil unless @parent_object
+      @parent_object.is_a?(Array) ? @parent_object.first : @parent_object
+    end
+
+    def initialize(attributes = {}, opts = {})
+      super
+
+      # Now we can safely use symbol keys only since parent normalized them
+      normalized_attrs = normalize_attributes(attributes)
+      @api_slug = normalized_attrs[:api_slug]
+      @name = normalized_attrs[:name]
+      @attio_object_id = normalized_attrs[:object_id]
+      @object_api_slug = normalized_attrs[:object_api_slug]
+      @created_by_actor = normalized_attrs[:created_by_actor]
+      @workspace_id = normalized_attrs[:workspace_id]
+      @workspace_access = normalized_attrs[:workspace_access]
+      @parent_object = normalized_attrs[:parent_object] || normalized_attrs[:object]
+      @filters = normalized_attrs[:filters]
+    end
+
+    def resource_path
+      raise InvalidRequestError, "Cannot generate path without an ID" unless persisted?
+      list_id = id.is_a?(Hash) ? (id[:list_id] || id["list_id"]) : id
+      "#{self.class.resource_path}/#{list_id}"
+    end
+
+    # Override the default id extraction for API paths
+    def id_for_path
+      return nil unless persisted?
+      id.is_a?(Hash) ? (id[:list_id] || id["list_id"]) : id
+    end
+
+    # Override save to handle nested ID
+    def save(**)
+      raise InvalidRequestError, "Cannot save a list without an ID" unless persisted?
+      return self unless changed?
+
+      list_id = id.is_a?(Hash) ? (id[:list_id] || id["list_id"]) : id
+      self.class.update(list_id, changed_attributes, **)
+    end
+
+    # Lists cannot be deleted via API
+    def destroy(**opts)
+      raise NotImplementedError, "Lists cannot be deleted via the Attio API"
+    end
+
+    # Get all entries in this list
+    def entries(params = {}, **opts)
+      list_id = id.is_a?(Hash) ? (id[:list_id] || id["list_id"]) : id
+      client = Attio.client(api_key: opts[:api_key])
+      # Use POST query endpoint to get entries
+      response = client.post("lists/#{list_id}/entries/query", params)
+      response["data"] || []
+    end
+
+    # Add a record to this list
+    def add_record(record_id, **opts)
+      list_id = id.is_a?(Hash) ? id["list_id"] : id
+      client = Attio.client(api_key: opts[:api_key])
+
+      # The API expects parent_record_id, parent_object, and entry_values
+      request_data = {
+        data: {
+          parent_record_id: record_id,
+          parent_object: object, # Get the parent object from the list
+          entry_values: {}
+        }
+      }
+
+      response = client.post("lists/#{list_id}/entries", request_data)
+      # Return the entry data
+      response["data"] || response
+    end
+
+    # Remove a record from this list
+    def remove_record(entry_id, **opts)
+      list_id = id.is_a?(Hash) ? id["list_id"] : id
+      client = Attio.client(api_key: opts[:api_key])
+      client.delete("lists/#{list_id}/entries/#{entry_id}")
+    end
+
+    # Check if a record is in this list
+    def contains_record?(record_id, **)
+      entries({record_id: record_id}, **).any?
+    end
+
+    # Get the count of entries
+    def entry_count(**)
+      # Just get the entries and count them
+      entries(**).length
+    end
+
+    # Convert list to hash representation
+    # @return [Hash] List data as a hash
+    def to_h
+      super.merge(
+        api_slug: api_slug,
+        name: name,
+        object_id: attio_object_id,
+        object_api_slug: object_api_slug,
+        created_by_actor: created_by_actor,
+        workspace_id: workspace_id,
+        workspace_access: workspace_access
+      ).compact
+    end
+
+    class << self
+      # Override retrieve to handle complex IDs
+      def retrieve(id, **opts)
+        list_id = id.is_a?(Hash) ? id["list_id"] : id
+        response = execute_request(:GET, "#{resource_path}/#{list_id}", {}, opts)
+        new(response["data"] || response, opts)
+      end
+
+      # Override create to handle keyword arguments properly
+      def create(**kwargs)
+        # Extract options from 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 create to handle special parameters
+      def prepare_params_for_create(params)
+        validate_object_identifier!(params[:object])
+
+        # Generate api_slug from name if not provided
+        api_slug = params[:api_slug] || params[:name].downcase.gsub(/[^a-z0-9]+/, "_")
+
+        {
+          data: {
+            name: params[:name],
+            parent_object: params[:object],
+            api_slug: api_slug,
+            workspace_access: params[:workspace_access] || "full-access",
+            workspace_member_access: params[:workspace_member_access] || [],
+            filters: params[:filters]
+          }.compact
+        }
+      end
+
+      # Override update to handle data wrapper
+      def prepare_params_for_update(params)
+        {
+          data: params
+        }
+      end
+
+      # Find list by API slug
+      def find_by_slug(slug, **opts)
+        list(**opts).find { |lst| lst.api_slug == slug } ||
+          raise(NotFoundError, "List with slug '#{slug}' not found")
+      end
+
+      # Get lists for a specific object
+      def for_object(object, params = {}, **)
+        list(params.merge(object: object), **)
+      end
+
+      private
+
+      def validate_object_identifier!(object)
+        raise ArgumentError, "Object identifier is required" if object.nil? || object.to_s.empty?
+      end
+    end
+  end
+end

data/lib/attio/resources/meta.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "../api_resource"
+
+module Attio
+  # Provides metadata about the current API token and workspace
+  class Meta < APIResource
+    # Meta only supports the identify endpoint (no CRUD operations)
+
+    def self.resource_path
+      "self"
+    end
+
+    # Get information about the current token and workspace
+    def self.identify(**opts)
+      response = execute_request(:GET, resource_path, {}, opts)
+      new(response["data"] || response, opts)
+    end
+
+    class << self
+      # Convenient aliases
+      alias_method :self, :identify
+      alias_method :current, :identify
+    end
+
+    # Define attribute accessors
+    attr_attio :workspace, :token, :actor
+
+    # Convenience methods for workspace info
+    def workspace_id
+      workspace&.dig(:id)
+    end
+
+    # Get the workspace name
+    # @return [String, nil] The workspace name
+    def workspace_name
+      workspace&.dig(:name)
+    end
+
+    # Get the workspace slug
+    # @return [String, nil] The workspace slug
+    def workspace_slug
+      workspace&.dig(:slug)
+    end
+
+    # Convenience methods for token info
+    def token_id
+      token&.dig(:id)
+    end
+
+    # Get the token name
+    # @return [String, nil] The token name
+    def token_name
+      token&.dig(:name)
+    end
+
+    # Get the token type
+    # @return [String, nil] The token type
+    def token_type
+      token&.dig(:type)
+    end
+
+    # Get the token's OAuth scopes
+    # @return [Array<String>] Array of scope strings
+    def scopes
+      token&.dig(:scopes) || []
+    end
+
+    # Check if token has a specific scope
+    def has_scope?(scope)
+      scope_str = scope.to_s.tr("_", ":")
+      scopes.include?(scope_str)
+    end
+
+    # Check read/write permissions
+    def can_read?(resource)
+      has_scope?("#{resource}:read") || has_scope?("#{resource}:read-write")
+    end
+
+    def can_write?(resource)
+      has_scope?("#{resource}:write") || has_scope?("#{resource}:read-write")
+    end
+
+    # Meta is read-only
+    def immutable?
+      true
+    end
+
+    # Override save to raise error since meta is read-only
+    def save(**opts)
+      raise InvalidRequestError, "Meta information is read-only"
+    end
+
+    # Override destroy to raise error since meta is read-only
+    def destroy(**opts)
+      raise InvalidRequestError, "Meta information is read-only"
+    end
+
+    private
+
+    def to_h
+      {
+        workspace: workspace,
+        token: token,
+        actor: actor
+      }.compact
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} workspace=#{workspace_slug.inspect} token=#{token_name.inspect}>"
+    end
+  end
+end