Skip to content

A platform for community discussion. Free, open, simple.

6.2 KB
Raw Blame
# frozen_string_literal: true

module JsonApiKitSpec
  class GroupResource < JsonApiKit::Resource
    model Group
    type :groups

    attribute :name
  end

  class UserResource < JsonApiKit::Resource
    model User
    type :users

    attribute :username

    has_many :groups, resource: GroupResource
  end

  GroupResource.has_many(:users, resource: UserResource)

  class CategoryResource < JsonApiKit::Resource
    model Category
    type :categories

    attribute :name
  end

  class TagResource < JsonApiKit::Resource
    model Tag
    type :tags

    attribute :name
  end

  class PostResource < JsonApiKit::Resource
    model Post
    type :posts

    sort :post_number
    default_sort post_number: :asc
    page default: 2, max: 10

    attribute :post_number

    has_one :user, resource: UserResource
  end

  class TopicResource < JsonApiKit::Resource
    model Topic
    type :topics

    sort :created_at
    sort :title
    sort :last_posted_at
    sort "category.name"
    default_sort created_at: :desc

    filter :title

    anchor :id
    anchor :created_at
    anchor :title
    anchor :last_posted_at
    anchor(:mine) { |topics, guardian| topics.where(user_id: guardian.user&.id) }
    anchor(:without_replies) { |topics, _guardian| topics.where(posts_count: 0) }

    attribute :title
    attribute :created_at

    has_one :user, resource: UserResource
    has_one :category, resource: CategoryResource
    has_many :tags, resource: TagResource
    has_many :posts, resource: PostResource
    has_many :ordered_posts, resource: PostResource

    includes "user.groups", "user.groups.users", "posts.topic", "posts.user", "posts.user.groups"
  end

  PostResource.has_one(:topic, resource: TopicResource)
end

RSpec.shared_context "with a listing of topics" do
  fab!(:oldest) do
    Fabricate(:topic, title: "Anchors and centred pages", created_at: Time.utc(2026, 8, 1))
  end
  fab!(:middle) do
    Fabricate(:topic, title: "Cursors that survive a redesign", created_at: Time.utc(2026, 8, 2))
  end
  fab!(:newest) do
    Fabricate(:topic, title: "Bands of a segmented listing", created_at: Time.utc(2026, 8, 3))
  end

  let(:resource) { JsonApiKitSpec::TopicResource }
  let(:guardian) { Guardian.new }
  let(:params) { {} }
  let(:base) { "https://example.com/api" }
  let(:current) { "https://example.com/api/topics" }
  let(:query) { {} }
  let(:scoped_to) { nil }
  let(:edition) { JsonApiKit::Edition.current }
  let(:urls) { JsonApiKit::Urls.new(base:, current:, parameters: query) }
  let(:client) { JsonApiKit::Client.new(guardian:, edition:, urls:) }
  let(:document) do
    JsonApiKit::Document::Collection.for(params, resource:, client:, scoped_to:).to_h
  end

  def one_document(id, **options)
    JsonApiKit::Document::Individual.for(id, params, resource:, client:, **options).to_h
  end

  def listing_of(parameters)
    JsonApiKit::Document::Collection.for(
      parameters,
      resource:,
      client:
        JsonApiKit::Client.new(guardian:, edition:, urls: JsonApiKit::Urls.new(base:, current:)),
      scoped_to:,
    ).to_h
  end

  def cursor_of(row) = row[:meta][:page][:cursor]

  def topic_object(topic, fields: %w[title createdAt], **members)
    resource_object(
      "topics",
      topic,
      { "title" => topic.title, "createdAt" => topic.created_at }.slice(*fields),
      **members,
    )
  end

  def user_object(user, fields: %w[username], **members)
    resource_object("users", user, { "username" => user.username }.slice(*fields), **members)
  end

  def group_object(group, fields: %w[name], **members)
    resource_object("groups", group, { "name" => group.name }.slice(*fields), **members)
  end

  def category_object(category, fields: %w[name], **members)
    resource_object("categories", category, { "name" => category.name }.slice(*fields), **members)
  end

  def tag_object(tag, fields: %w[name], **members)
    resource_object("tags", tag, { "name" => tag.name }.slice(*fields), **members)
  end

  def post_object(post, fields: %w[postNumber], **members)
    resource_object("posts", post, { "postNumber" => post.post_number }.slice(*fields), **members)
  end

  def resource_object(type, row, attributes, cursor: nil, relationships: nil)
    {
      type:,
      id: row.id.to_s,
      attributes: attributes.presence,
      relationships:,
      meta: cursor && { page: { cursor: } },
      links: {
        self: "#{base}/#{type}/#{row.id}",
      },
    }.compact
  end

  def relationship_object(type, row, name, data:)
    {
      data:,
      links: {
        self: "#{base}/#{type}/#{row.id}/relationships/#{name}",
        related: "#{base}/#{type}/#{row.id}/#{name}",
      },
    }
  end

  def identifier_of(type, row) = { type:, id: row.id.to_s }

  def paged_relationship_object(type, row, name, data:, next_page: nil)
    relationship_object(type, row, name, data:).deep_merge(links: { prev: nil, next: next_page })
  end

  def refusal(title:, detail:, parameter: nil, header: nil, status: "400", **members)
    source = { parameter:, header: }.compact.presence
    { status:, title:, detail:, source:, **members }.compact
  end

  def not_found = refusal(status: "404", title: "No such record", detail: "No record has this ID.")

  def profile_link(name) = "https://jsonapi.org/profiles/ethanresnick/cursor-pagination/#{name}"

  def self_link
    href = query.blank? ? current : "#{current}?#{query_of(query)}"
    { href:, type: JsonApiKit::Pagination::Profile::MEDIA_TYPE }
  end

  def query_of(hash) = Rack::Utils.build_nested_query(hash)

  def links_of(**pages) = { self: self_link, **{ prev: nil, next: nil }.merge(pages) }

  def page_url(**page)
    "#{current}?#{query_of(query.merge("page" => page))}"
  end

  def cursor_at(index, rendered = document) = cursor_of(rendered[:data][index])

  def parameters_of(url) = Rack::Utils.parse_nested_query(URI.parse(url).query)

  def cursor_of_record(record, of: resource, sort: of.default_ordering)
    order = of.order(sort.transform_keys(&:to_s))
    order.locate(of.model.where(id: record.id)).cursor.to_s
  end

  def relationship_page_url(type, row, name, **page)
    "#{base}/#{type}/#{row.id}/#{name}?#{query_of(page: page)}"
  end

  def listed_ids(rendered = document) = rendered[:data].map { it[:id] }

  def rendered_error(rendered = document) = rendered[:errors].sole
end