api_cursor_pagination 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 70156ccecccc0ef4276361c8a58d3f701a3ab0d4fe83a4adbb443e075f1a969b
+  data.tar.gz: d81321a10c68c5417676cc785d647ffe3ab1e75c2468ccbaf34675991649c533
+SHA512:
+  metadata.gz: 538461c6cc31fd905b810f4cf780fba10dbcd35aa814db54882413f972a8002260d41c680798f3dca69e5a57a5fd741df49a685e468455e2e24eeadc2d25576b
+  data.tar.gz: 27ee1766643580f2bd225bd7a04ca53898af70b079f7f663b1f94004e40cbacdd4cca06b2fee5ed30b39cb85d9b6803d118ba9259bf189ac0bf95eba8bf66721

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2024-01-XX
+
+### Added
+- Initial release of ApiCursorPagination gem
+- Cursor-based pagination concern for Rails controllers
+- JSON:API compliant pagination following the cursor pagination profile
+- Support for `page[size]`, `page[before]`, and `page[after]` parameters
+- Comprehensive error handling and validation
+- Pagination metadata generation with `meta` and `links`
+- Support for custom cursor fields and complex queries
+- RSpec test suite with comprehensive coverage
+- Documentation and usage examples
+- Ruby >= 2.5 and Rails >= 5.0 compatibility
+
+### Features
+- `validate_and_setup_page_params` method for page request parameter validation
+- `paginate` method for retrieving paginated results
+- `page_links_and_meta_data` method for generating pagination metadata
+- Proper error responses for invalid parameters
+- Support for bidirectional pagination (before/after cursors)
+- Total count and page calculation
+- Automatic link generation for next/previous pages
+
+[Unreleased]: https://github.com/yourusername/api_cursor_pagination/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/yourusername/api_cursor_pagination/releases/tag/v1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 prashm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 ApiCursorPagination Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,320 @@
+# ApiCursorPagination
+
+[![Gem Version](https://badge.fury.io/rb/api_cursor_pagination.svg)](https://badge.fury.io/rb/api_cursor_pagination)
+[![Build Status](https://github.com/prashm/api_cursor_pagination/workflows/CI/badge.svg)](https://github.com/prashm/api_cursor_pagination/actions)
+
+A Rails concern that implements cursor-based pagination for APIs, following the [JSON:API cursor pagination profile](https://jsonapi.org/profiles/ethanresnick/cursor-pagination/).
+
+## Features
+
+- 🚀 **Efficient Pagination**: Cursor-based pagination for large datasets
+- 📊 **JSON:API Compliant**: Follows the JSON:API cursor pagination specification
+- 🔧 **Easy Integration**: Simple Rails concern that can be included in any controller
+- 🎯 **Flexible**: Supports custom cursor fields and query scopes
+- ✅ **Well Tested**: Comprehensive test suite included
+- 🛡️ **Error Handling**: Built-in validation and error responses
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'api_cursor_pagination'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install api_cursor_pagination
+```
+
+Or simply include the concern file (lib/api_cursor_pagination/concern.rb) in your app/controllers/concerns folder.
+
+
+## Requirements
+
+- Ruby >= 2.5.0
+- Rails >= 5.0
+- ActiveSupport >= 5.0
+
+## Usage
+
+### Basic Setup
+
+Include the concern in your API controller:
+
+```ruby
+class UsersController < ApplicationController
+  include ApiCursorPagination::Concern
+
+  def index
+    # Initialize errors array
+    @errors = []
+    
+    # Validate and set pagination options from params
+    validate_and_setup_page_params(params[:page])
+
+    if @errors.blank?
+      # Build your query scope
+      scope = User.active.includes(:profile).select('users.*, profiles.*, users.id user_id')
+      
+      # Get paginated results
+      users = paginate(scope, 'users_id')
+
+      # Build API response with pagination metadata
+      response = {
+        status: 'Success',
+        data: users.map(&:as_json)
+      }.merge(page_links_and_meta_data(request.base_url + request.path, request.query_parameters))
+
+      render json: response, status: :ok
+    else
+      render json: error_response, status: :bad_request
+    end
+  end
+
+  private
+
+  def error_response
+    {
+      status: 'Error',
+      errors: @errors.map { |error| error.is_a?(Hash) ? error : { title: error } }
+    }
+  end
+end
+```
+
+### API Usage
+
+#### Request Format
+
+Pagination parameters should be passed in the `page` parameter:
+
+```
+GET /api/users?page[size]=10
+GET /api/users?page[size]=10&page[after]=123
+GET /api/users?page[size]=10&page[before]=456
+```
+
+#### Parameters
+
+- `page[size]` (required): Number of records per page (must be positive integer)
+- `page[after]` (optional): Cursor to get records after this ID
+- `page[before]` (optional): Cursor to get records before this ID
+- `page[sort]` (not supported): Will return an error if provided
+
+**Note**: You cannot use both `page[before]` and `page[after]` in the same request.
+
+#### Response Format
+
+```json
+{
+  "status": "Success",
+  "data": [...],
+  "meta": {
+    "page": {
+      "cursor": {
+        "before": 123,
+        "after": 456
+      },
+      "total": 1000,
+      "pages": 100
+    }
+  },
+  "links": {
+    "prev": "https://api.example.com/users?page[before]=123&page[size]=10",
+    "next": "https://api.example.com/users?page[after]=456&page[size]=10"
+  }
+}
+```
+
+### Advanced Usage
+
+#### Custom Cursor Fields
+
+You can use different fields for the SQL query scope and the returned row IDs:
+
+```ruby
+# If your query uses a complex cursor but rows have simple IDs
+scope = User.joins(:orders).select('users.*, CAST(CONCAT(users.id, ".", IFNULL(orders.id, 0)) AS DECIMAL(40,20)) as cursor_id')
+users = paginate(scope, 'cursor_id')
+```
+
+#### Complex Queries
+
+The concern works with any ActiveRecord scope:
+
+```ruby
+def index
+  validate_and_setup_page_params(params[:page])
+  
+  if @errors.blank?
+    scope = User.joins(:orders)
+                .where(orders: { status: 'active' })
+                .group('users.id')
+                .select('users.*, MAX(orders.created_at) as last_order_date')
+                
+    users = paginate(scope, 'last_order_date')
+    
+    # ... render response
+  end
+end
+```
+
+## API Reference
+
+### Methods
+
+#### `validate_and_setup_page_params(params)`
+
+Validates pagination parameters and sets instance variables.
+
+**Parameters:**
+- `params` - The request parameters hash
+
+**Sets:**
+- `@page_size` - Number of records per page
+- `@page_before` - Cursor for pagination before this ID
+- `@page_after` - Cursor for pagination after this ID
+- `@errors` - Array of validation errors
+
+#### `paginate(scope, scope_id_str, row_id_str = scope_id_str)`
+
+Returns paginated results from the given scope.
+
+**Parameters:**
+- `scope` - ActiveRecord scope/relation
+- `scope_id_str` - Field name used in SQL queries for cursor comparison
+- `row_id_str` - Field name on returned objects for cursor values (defaults to scope_id_str)
+
+**Returns:** Array of records
+
+**Sets:**
+- `@total_size` - Total number of records in scope
+- `@total_pages` - Total number of pages
+- `@next_page_cursor_id` - Cursor ID for next page
+- `@prev_page_cursor_id` - Cursor ID for previous page
+
+#### `page_links_and_meta_data(base_url, query_params)`
+
+Generates pagination metadata and links.
+
+**Parameters:**
+- `base_url` - Base URL for pagination links
+- `query_params` - Current query parameters
+
+**Returns:** Hash with `meta` and `links` keys
+
+## Error Handling
+
+The gem provides detailed error responses for various scenarios:
+
+### Invalid Page Size
+```json
+{
+  "title": "Invalid Parameter.",
+  "detail": "page[size] is required and must be a positive integer; got 0",
+  "source": { "parameter": "page[size]" }
+}
+```
+
+### Unsupported Sort
+```json
+{
+  "title": "Unsupported Sort.",
+  "detail": "page[sort] is not supported; got page[sort]=name",
+  "source": { "parameter": "page[sort]" },
+  "links": { "type": ["https://jsonapi.org/profiles/ethanresnick/cursor-pagination/unsupported-sort"] }
+}
+```
+
+### Range Pagination Not Supported
+```json
+{
+  "title": "Range Pagination Not Supported.",
+  "detail": "Range pagination not supported; got page[before]=123 and page[after]=456",
+  "links": { "type": ["https://jsonapi.org/profiles/ethanresnick/cursor-pagination/range-pagination-not-supported"] }
+}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Running Tests
+
+```bash
+# Run all tests
+bundle exec rake spec
+
+# Run with coverage
+bundle exec rspec
+
+# Run linting
+bundle exec rubocop
+```
+
+### Code Quality
+
+This gem follows Ruby best practices and includes:
+
+- RuboCop for code style enforcement
+- RSpec for comprehensive testing
+- Semantic versioning
+- Changelog maintenance
+
+## Performance Considerations
+
+Cursor-based pagination is generally more efficient than offset-based pagination, especially for large datasets. However, keep these points in mind:
+
+1. **Database Indexes**: Ensure your cursor field is properly indexed
+2. **Query Complexity**: Complex joins may impact performance
+3. **Total Count**: The `total_size` calculation runs a separate COUNT query
+4. **Memory Usage**: Large page sizes will use more memory
+
+## Comparison with Offset Pagination
+
+| Feature | Cursor Pagination | Offset Pagination |
+|---------|------------------|-------------------|
+| Performance on large datasets | ✅ Excellent | ❌ Degrades |
+| Consistent results during data changes | ✅ Yes | ❌ No |
+| Jump to arbitrary page | ❌ No | ✅ Yes |
+| Bi-directional navigation | ✅ Yes | ✅ Yes |
+| Implementation complexity | 🟡 Medium | ✅ Simple |
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/prashm/api_cursor_pagination. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/prashm/api_cursor_pagination/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ApiCursorPagination project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/prashm/api_cursor_pagination/blob/main/CODE_OF_CONDUCT.md).
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a list of changes.
+
+## Support
+
+If you have any questions or issues, please:
+
+1. Check the [documentation](https://github.com/prashm/api_cursor_pagination)
+2. Search [existing issues](https://github.com/prashm/api_cursor_pagination/issues)
+3. Create a [new issue](https://github.com/prashm/api_cursor_pagination/issues/new) if needed
+
+## Acknowledgments
+
+- Based on the [JSON:API cursor pagination profile](https://jsonapi.org/profiles/ethanresnick/cursor-pagination/)
+- Inspired by best practices from various pagination implementations

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+desc "Run tests"
+task default: %i[spec rubocop]

data/api_cursor_pagination.gemspec

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "lib/api_cursor_pagination/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "api_cursor_pagination"
+  spec.version = ApiCursorPagination::VERSION
+  spec.authors = ["Prashant Mokkarala"]
+  spec.email = ["prashm@gmail.com"]
+
+  spec.summary = "A Rails concern for implementing cursor-based pagination in APIs"
+  spec.description = "ApiCursorPagination provides a Rails concern that implements cursor-based pagination following the JSON:API cursor pagination profile. It allows for efficient pagination of large datasets by using cursor-based navigation instead of offset-based pagination."
+  spec.homepage = "https://github.com/prashm/api_cursor_pagination"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.5.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/prashm/api_cursor_pagination"
+  spec.metadata["changelog_uri"] = "https://github.com/prashm/api_cursor_pagination/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "activesupport", ">= 5.0"
+  spec.add_dependency "railties", ">= 5.0"
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rails", ">= 5.0"
+  spec.add_development_dependency "sqlite3", "~> 1.4"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+  spec.add_development_dependency "rubocop-rails", "~> 2.0"
+  spec.add_development_dependency "rubocop-rspec", "~> 2.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/api_cursor_pagination/concern.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+# Include this controller concern in your api controller class to enable cursor pagination
+# Example:
+# class ExampleApiController
+#   include ApiCursorPagination::Concern
+#
+#   def index
+#     validate_and_setup_page_params(params)
+#
+#     if @errors.blank?
+#       query_scope = build_your_sql_query_scope(params)
+#       rows = paginate(query_scope, 'row_id')
+#
+#       api_response = { status: 'Success', field_names: field_names }.
+#         merge(page_links_and_meta_data(request.original_url.split('?').first, request.query_parameters)).
+#         merge(results: rows).to_json
+#       render(json: api_response, status: 201)
+#     else
+#       render(json: status400_error_response.to_json, status: 400)
+#     end
+#   end
+#
+#   private
+#
+#   def status400_error_response
+#     response = { status: 'Error', errors: [] }
+#     @errors.each do |error|
+#       response[:errors] << (error.is_a?(Hash) ? error : { title: error })
+#     end
+#     response
+#   end
+# end
+
+module ApiCursorPagination
+  module Concern
+    extend ActiveSupport::Concern
+
+    # Based on https://jsonapi.org/profiles/ethanresnick/cursor-pagination/
+
+    attr_accessor :page_size, :page_before, :page_after,
+                  # Meta attrs
+                  :total_size, :total_pages, :next_page_cursor_id, :prev_page_cursor_id
+
+    def validate_and_setup_page_params(page_params)
+      @errors ||= []
+      self.page_size = 0
+      return if page_params.blank?
+      
+      self.page_size = page_params[:size].to_i
+      if page_size < 1
+        @errors << {
+          title: 'Invalid Parameter.',
+          detail: "page[size] is required and must be a positive integer; got #{page_params[:size]}",
+          source: { parameter: "page[size]" }
+        }
+      elsif page_params.has_key?(:sort)
+        @errors << {
+          title: 'Unsupported Sort.',
+          detail: "page[sort] is not supported; got page[sort]=#{page_params[:sort]}",
+          source: { parameter: "page[sort]" },
+          links: { type: ["https://jsonapi.org/profiles/ethanresnick/cursor-pagination/unsupported-sort"] }
+        }
+      elsif page_params.has_key?(:before) && page_params.has_key?(:after)
+        @errors << {
+          title: "Range Pagination Not Supported.",
+          detail: "Range pagination not supported; got page[before]=#{page_params[:before]} and page[after]=#{page_params[:after]}",
+          links: { type: ["https://jsonapi.org/profiles/ethanresnick/cursor-pagination/range-pagination-not-supported"] }
+        }
+      elsif page_params.has_key?(:before)
+        self.page_before = page_params[:before]
+        if self.page_before.blank?
+          @errors << {
+            title: 'Invalid Parameter.',
+            detail: 'page[before] is invalid',
+            source: { parameter: 'page[before]' }
+          }
+        end
+      elsif page_params.has_key?(:after)
+        self.page_after = page_params[:after]
+        if self.page_after.blank?
+          @errors << {
+            title: 'Invalid Parameter.',
+            detail: 'page[after] is invalid',
+            source: { parameter: 'page[after]' }
+          }
+        end
+      end
+
+    end
+
+    def paginate(scope, scope_id_str, row_id_str = scope_id_str)
+      if page_size > 0
+        self.total_size = scope.size
+        self.total_pages = total_size / page_size
+        self.total_pages += 1 if total_size % page_size > 0
+
+        scope = scope.having("#{scope_id_str} > ?", page_after) if page_after.present?
+        scope = scope.having("#{scope_id_str} < ?", page_before) if page_before.present?
+        scope = scope.limit(page_size)
+        if page_before.present? && page_after.blank?
+          scope = scope.order("#{scope_id_str} desc")
+          rows = scope.to_a.sort_by{|r| r.send(row_id_str)}
+        else
+          rows = scope.order(scope_id_str).to_a
+        end
+
+        self.next_page_cursor_id = rows.last&.send(row_id_str)
+        self.prev_page_cursor_id = rows.first&.send(row_id_str)
+        rows
+      else
+        scope.to_a
+      end
+    end
+
+    def page_links_and_meta_data(base_url, query_params)
+      if page_size > 0
+        cursor = {}
+        cursor[:before] = prev_page_cursor_id if prev_page_cursor_id.present?
+        cursor[:after] = next_page_cursor_id if next_page_cursor_id.present?
+        meta_hash = {
+          meta: {
+            page: { cursor: cursor, total: total_size, pages: total_pages }
+          }
+        }
+        meta_hash[:links] = {}
+        if prev_page_cursor_id.present?
+          query_string = query_params.merge(page: { before: prev_page_cursor_id, size: page_size }).to_query
+          meta_hash[:links].merge!(prev: "#{base_url}?#{query_string}")
+        end
+        if next_page_cursor_id.present?
+          query_string = query_params.merge(page: { after: next_page_cursor_id, size: page_size }).to_query
+          meta_hash[:links].merge!(next: "#{base_url}?#{query_string}")
+        end
+        meta_hash
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/api_cursor_pagination/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ApiCursorPagination
+  VERSION = "1.0.0"
+end

data/lib/api_cursor_pagination.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "api_cursor_pagination/version"
+require_relative "api_cursor_pagination/concern"
+
+module ApiCursorPagination
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: api_cursor_pagination
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Prashant Mokkarala
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: ApiCursorPagination provides a Rails concern that implements cursor-based
+  pagination following the JSON:API cursor pagination profile. It allows for efficient
+  pagination of large datasets by using cursor-based navigation instead of offset-based
+  pagination.
+email:
+- prashm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- api_cursor_pagination.gemspec
+- lib/api_cursor_pagination.rb
+- lib/api_cursor_pagination/concern.rb
+- lib/api_cursor_pagination/version.rb
+homepage: https://github.com/prashm/api_cursor_pagination
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/prashm/api_cursor_pagination
+  source_code_uri: https://github.com/prashm/api_cursor_pagination
+  changelog_uri: https://github.com/prashm/api_cursor_pagination/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A Rails concern for implementing cursor-based pagination in APIs
+test_files: []