PackAPI

gem 'pack_api'

# public/author_type.rb
class AuthorType < PackAPI::Types::BaseType
  attribute :id, ::Types::String
  attribute :name, ::Types::String
end

# public/comment_type.rb
class CommentType < PackAPI::Types::BaseType
  attribute :text, ::Types::String
end

# public/blog_post_type.rb
class BlogPostType < PackAPI::Types::BaseType
  attribute :id, ::Types::String
  attribute :legacy_id, ::Types::String
  attribute :title, ::Types::String
  attribute :persisted, ::Types::Bool
  attribute :contents, ::Types::String.optional
  optional_attribute :associated, AuthorType
  optional_attribute :notes, ::Types::Array.of(CommentType)
  optional_attribute :earnings_float, ::Types::Coercible::Float
end

# api/author_attribute_map.rb
class AuthorAttributeMap < PackAPI::Mapping::AttributeMap
  api_type AuthorType
  model_type Author
  map :name, to: :name
  map :id, to: :external_id
  map :blog_posts
end

# api/comment_attribute_map.rb
class CommentAttributeMap < PackAPI::Mapping::AttributeMap
  api_type CommentType
  model_type Comment
  map :text, to: :txt
end

# api/blog_post_attribute_map.rb
class BlogPostAttributeMap < PackAPI::Mapping::AttributeMap
  api_type BlogPostType
  model_type BlogPost

  # example API attribute mapped to a model attribute of the same name
  map :title

  map :contents, from_model_attribute: ->(attachment) { attachment&.blob }

  # example API attribute mapped to a model attribute of a different name
  map :id, to: :external_id

  # example of API attribute ending in "_id"
  map :legacy_id

  # example of API attribute mapped to a model method (unidirectional)
  map :persisted, to: :persisted?, readonly: true

  # example of API association mapped to a model association
  # (the association_id can also be passed in, and reported on during error cases)
  map :associated, to: :author,
      from_api_attribute: ->(author_id) { Author.find_by(external_id: author_id) }

  map :notes, to: :comments, transform_nested_attributes_with: CommentAttributeMap

  # example of OPTIONAL API attribute (association) mapped to a model method (bidirectional)
  map :earnings_float, to: :earnings_float
end

def query_blog_posts(cursor = nil, search = nil, sort = nil, page_size = 50, filters = {}, optional_attributes = [])
  collection = BlogPost.all
  
  # avoid N+1 queries for optional attributes that are associations
  if optional_attributes.include?(:associated)
    collection = collection.includes(:author)
  end
  
  # convert the search terms to something used by the CollectionQuery to perform searches (hash of model attributes to search terms)
  if search.present?
    # search through blog post title and comments
    collection = collection.includes(:comments)
    model_search = {
      'title' => search,
      "#{Comment.table_name}.txt" => search,
    }
  end
  
  # convert the API sort to model sort
  model_sort = BlogPostAttributeMap.model_attribute_keys(PackAPI::Querying::SortHash.new(sort))

  # convert the API filters to model filters
  model_filters = BlogPostFilterMap.new.from_api_filters(filters)

  # build and execute the query
  query = PackAPI::Querying::CollectionQuery.new(collection:)
  query.filter_factory = Filters::BlogPost::FilterFactory.new
  query.call(cursor:, per_page: page_size, sort: model_sort, search: model_search, filters: model_filters)
  
  # build and return the result
  PackAPI::Types::Result.from_collection(models: query.results,
                                         value_object_factory: ValueObjectFactory.new,
                                         optional_attributes:,
                                         sort: BlogPostAttributeMap.api_attribute_keys(query.sort),
                                         paginator: query.paginator)
end

# Load all shared examples
require 'pack_api/rspec/shared_examples_for_api_query_methods'
require 'pack_api/rspec/shared_examples_for_paginated_results'

# Or load them individually as needed
require 'pack_api/rspec/shared_examples_for_api_query_methods'

RSpec.describe 'query_blog_posts' do
  let(:api_query_method) { method(:query_blog_posts) }
  let(:resources) { BlogPost.all }

  it_behaves_like 'an API query method'

  # With custom options
  it_behaves_like 'an API query method',
    model_id_attribute: :uuid,
    supports_search: true do
    let(:search_terms) { "searchable text" }
    let(:matched_resources) { BlogPost.where("title LIKE ?", "%searchable%") }
  end
end

RSpec.describe 'paginated query' do
  let(:paginated_api_query_method) { method(:query_blog_posts) }
  let(:paginated_resources) { BlogPost.all }

  it_behaves_like 'a paginated API method', model_id_attribute: :external_id
end