rails_audit_log-graphql 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35b1c07883c1e3b4036690804d2cf1600e484771b49a58f3954278d39fb136ae
+  data.tar.gz: 15b543bf26d1d19ff3e8fbc29488871f325d492cef51b215c60dff8d1f22906b
+SHA512:
+  metadata.gz: 9409ded3977d2fa0f31f5a60be9bf841cabe5e324aed231e8119fc59c433988affe7ab7f873aa31e1de7a2538f054e281c1af46f4946632fa2cff46d39ad35f5
+  data.tar.gz: f52a3c3d184d1ff8f201011ca014338e4a13b3d1a3d055f1372ea5fa72f4a2898765cde924777d38e5843f21b3319ee13a309cb6e4b37b23130f4986a559daf1

data/.standard.yml

@@ -0,0 +1,6 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.2
+
+ignore:
+  - "benchmarks/**/*"

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-06-03
+
+### Added
+
+- `AuditLogEntryType` GraphQL object type exposing all 13 `RailsAuditLog::AuditLogEntry` fields
+- `BaseObject` base class for all gem GraphQL types
+- `AuditLogEntriesQueryMixin` — include into host app's `QueryType` to add `auditLogEntry(id:)` and `auditLogEntries(event:, itemType:, itemId:, actorId:, page:, perPage:)` queries
+- Authentication support — `RailsAuditLog.authenticate` is respected; block receives the GraphQL context and raises `GraphQL::ExecutionError` when it returns falsy
+- `rails g rails_audit_log:graphql:install` generator — injects `AuditLogEntriesQueryMixin` into `app/graphql/types/query_type.rb`
+

data/CLAUDE.md

@@ -0,0 +1,89 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+`solid_queue_web` is a mountable Rails engine (published as a gem) that provides a web dashboard for [Solid Queue](https://github.com/rails/solid_queue). It has no host application — development and testing both use the dummy Rails app under `spec/dummy/`.
+
+## Commands
+
+```bash
+# Run the full suite (rubocop + rspec) — this is what CI runs
+bundle exec rake
+
+# Run only tests
+bundle exec rspec
+
+# Run a single spec file
+bundle exec rspec spec/requests/solid_queue_web/jobs_spec.rb
+
+# Run a single example by line number
+bundle exec rspec spec/requests/solid_queue_web/jobs_spec.rb:42
+
+# Lint
+bin/rubocop
+
+# Set up and seed the development database (dummy app)
+bundle exec rake dev:setup   # creates and migrates spec/dummy/db/development.sqlite3
+bundle exec rake dev:seed    # populates with realistic fake jobs/processes
+
+# Reset dev database (setup + seed)
+bundle exec rake dev:reset
+
+# Start the dummy app for manual testing
+cd spec/dummy && bin/rails server
+# Dashboard is at http://localhost:3000/jobs
+```
+
+## Architecture
+
+### Engine isolation
+
+The engine uses `isolate_namespace SolidQueueWeb`, so all routes, controllers, helpers, and models live under that namespace. The engine requires no database migrations of its own — it reads directly from the host app's Solid Queue tables via `SolidQueue::*` models (a declared gem dependency).
+
+### Execution model pattern
+
+Solid Queue represents job state with separate execution tables. Each status maps to a distinct ActiveRecord model:
+
+| Status      | Model                              |
+|-------------|------------------------------------|
+| `ready`     | `SolidQueue::ReadyExecution`       |
+| `scheduled` | `SolidQueue::ScheduledExecution`   |
+| `claimed`   | `SolidQueue::ClaimedExecution`     |
+| `blocked`   | `SolidQueue::BlockedExecution`     |
+| `failed`    | `SolidQueue::FailedExecution`      |
+
+`JobsController` maps the `?status=` param to these models via `EXECUTION_MODELS`. Only `ready`, `scheduled`, and `blocked` jobs can be discarded from the jobs list (`DISCARDABLE`); failed jobs have their own `FailedJobsController` with retry/discard.
+
+### No asset pipeline dependency
+
+CSS is delivered entirely via the `inline_styles` helper, which reads `application.css` at request time and injects it as a `<style>` tag. This prevents conflicts when mounted in any host app. There is no JavaScript — queue pause/resume and job discard use standard form POSTs or Turbo Stream responses.
+
+### Turbo Stream responses
+
+`JobsController#destroy` responds to both HTML and `turbo_stream` format. When a job is discarded:
+- If more jobs remain in the filtered scope → removes that row from the DOM.
+- If it was the last job → replaces the table with an empty-state element (`sqd-empty`).
+
+### Authentication
+
+`SolidQueueWeb.authenticate` stores a single block (set via an initializer in the host app). `ApplicationController#authenticate!` runs that block in controller context via `instance_exec`. If the block returns falsy, it falls back to HTTP Basic auth. No auth is enforced by default.
+
+### Pagination
+
+Pagy is included via `Pagy::Method` (not `Pagy::Backend`) and configured globally in the engine initializer with a limit of 25.
+
+### Test setup
+
+`spec/rails_helper.rb` loads `spec/dummy/db/schema.rb` directly on every test run (no migrations). Tests are all request specs that hit the dummy app's mounted engine at `/jobs`. Factories are not used — records are created directly with `SolidQueue::*` models.
+
+### Releasing
+
+`bin/release <version>` — bumps the version file, updates `Gemfile.lock` and `CHANGELOG.md`, commits, tags, and pushes. CI picks up the tag and publishes to RubyGems via Trusted Publishing. Must be run from `main` with a clean working tree.
+
+### CHANGELOG conventions
+
+- New entries go under `## [Unreleased]` on the feature branch, before opening a PR.
+- Sections within each version must appear in this order: `### Added`, `### Changed`, `### Fixed`. Omit sections that have no entries — never add an empty section header.
+- Branch workflow: always commit on a `feat/*` or `chore/*` branch; never commit directly to `main`.

data/CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eclectic-coding/rails_audit_log-graphql.
+
+## Development Setup
+
+```bash
+git clone https://github.com/eclectic-coding/rails_audit_log-graphql.git
+cd rails_audit_log-graphql
+bin/setup
+```
+
+## Running the Test Suite
+
+```bash
+bundle exec rake          # lint (StandardRB) + tests — this is what CI runs
+bundle exec rspec         # tests only
+bundle exec standardrb    # lint only
+```
+
+All pull requests must pass the full suite before merging.
+
+## Branch Workflow
+
+- Branch from `main` using a `feat/*` or `chore/*` prefix
+- One logical change per branch
+- Open a pull request against `main`; CI must be green before merge
+
+## Changelog
+
+Add an entry under `## [Unreleased]` in `CHANGELOG.md` with every PR. Use the appropriate section:
+
+- `### Added` — new functionality
+- `### Changed` — changes to existing behaviour
+- `### Fixed` — bug fixes
+
+## Roadmap
+
+When a feature listed in `ROADMAP.md` is completed, remove its bullet in the same PR that implements it.
+
+## Code Style
+
+This project uses [Standard Ruby](https://standardrb.com) (`standard` gem). Run `bundle exec rake standard:fix` to auto-correct violations before committing.
+
+## RBS Signatures
+
+Update `sig/rails_audit_log/graphql.rbs` when adding or changing public classes and modules.
+
+## Releasing
+
+Releases are managed by the maintainer. Do not bump `version.rb` in feature PRs.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Chuck Smith
+
+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,130 @@
+# RailsAuditLog::Graphql
+
+[![CI](https://github.com/eclectic-coding/rails_audit_log-graphql/actions/workflows/main.yml/badge.svg)](https://github.com/eclectic-coding/rails_audit_log-graphql/actions/workflows/main.yml)
+[![Gem Version](https://img.shields.io/gem/v/rails_audit_log-graphql)](https://rubygems.org/gems/rails_audit_log-graphql)
+[![Total Downloads](https://img.shields.io/gem/dt/rails_audit_log-graphql)](https://rubygems.org/gems/rails_audit_log-graphql)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.3-CC342D)](https://www.ruby-lang.org)
+[![codecov](https://codecov.io/gh/eclectic-coding/rails_audit_log-graphql/graph/badge.svg)](https://codecov.io/gh/eclectic-coding/rails_audit_log-graphql)
+
+A [graphql-ruby](https://graphql-ruby.org) API layer for the [`rails_audit_log`](https://github.com/eclectic-coding/rails_audit_log) gem. Provides ready-made GraphQL types, queries, and subscriptions for querying audit log entries — without coupling `graphql-ruby` to the base gem.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [AuditLogEntryType](#auditlogentrytype)
+  - [AuditLogEntriesQueryMixin](#auditlogentriesquerymixin)
+    - [auditLogEntry](#auditlogentryid-id-auditlogentry)
+    - [auditLogEntries](#auditlogentries-auditlogentry)
+  - [Authentication](#authentication)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+
+Add to your application's Gemfile:
+
+```ruby
+gem "rails_audit_log"
+gem "rails_audit_log-graphql"
+```
+
+Then run the install generator to wire up your schema:
+
+```bash
+rails g rails_audit_log:graphql:install
+```
+
+This injects `include RailsAuditLog::Graphql::Queries::AuditLogEntriesQueryMixin` into `app/graphql/types/query_type.rb`. If that file doesn't exist, the generator prints the line for you to add manually.
+
+[↑ Back to top](#table-of-contents)
+
+## Usage
+
+### AuditLogEntryType
+
+`RailsAuditLog::Graphql::Types::AuditLogEntryType` is a graphql-ruby object type that maps directly to `RailsAuditLog::AuditLogEntry`.
+
+| GraphQL field | Type | Nullable |
+|---|---|---|
+| `id` | `ID` | no |
+| `event` | `String` | no |
+| `itemType` | `String` | no |
+| `itemId` | `ID` | no |
+| `createdAt` | `ISO8601DateTime` | no |
+| `objectChanges` | `JSON` | yes |
+| `object` | `JSON` | yes |
+| `metadata` | `JSON` | yes |
+| `reason` | `String` | yes |
+| `whodunnitSnapshot` | `String` | yes |
+| `actorType` | `String` | yes |
+| `actorId` | `ID` | yes |
+| `tenantId` | `String` | yes |
+
+[↑ Back to top](#table-of-contents)
+
+### AuditLogEntriesQueryMixin
+
+Include `RailsAuditLog::Graphql::Queries::AuditLogEntriesQueryMixin` into your app's `QueryType` to add two fields:
+
+```ruby
+# app/graphql/types/query_type.rb
+class Types::QueryType < Types::BaseObject
+  include RailsAuditLog::Graphql::Queries::AuditLogEntriesQueryMixin
+end
+```
+
+#### `auditLogEntry(id: ID!): AuditLogEntry`
+
+Fetch a single entry by ID. Returns `nil` if not found.
+
+#### `auditLogEntries(...): [AuditLogEntry!]!`
+
+List entries with optional filters and offset pagination.
+
+| Argument | Type | Default | Description |
+|---|---|---|---|
+| `event` | `String` | — | Filter by event type (`create`, `update`, `destroy`) |
+| `itemType` | `String` | — | Filter by audited model class name |
+| `itemId` | `ID` | — | Filter by audited record ID |
+| `actorId` | `ID` | — | Filter by actor ID |
+| `page` | `Int` | `1` | Page number (1-based) |
+| `perPage` | `Int` | `25` | Results per page |
+
+Results are ordered by `created_at DESC`.
+
+[↑ Back to top](#table-of-contents)
+
+### Authentication
+
+If `RailsAuditLog.authenticate` is configured, the block is called with the GraphQL context before every query. Return a truthy value to allow access; return falsy to raise `GraphQL::ExecutionError` with `"Unauthorized"`.
+
+```ruby
+RailsAuditLog.configure do |config|
+  config.authenticate { |ctx| ctx[:current_user]&.admin? }
+end
+```
+
+If no authenticate block is set, all queries are permitted.
+
+[↑ Back to top](#table-of-contents)
+
+## Development
+
+```bash
+bin/setup         # install dependencies
+bundle exec rake  # lint + tests
+```
+
+[↑ Back to top](#table-of-contents)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+[↑ Back to top](#table-of-contents)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/ROADMAP.md

@@ -0,0 +1,57 @@
+# Roadmap
+
+This gem adds a GraphQL API layer on top of [`rails_audit_log`](https://github.com/eclectic-coding/rails_audit_log). It is intentionally a separate gem so that `graphql-ruby` remains an optional dependency for host applications.
+
+---
+
+## 0.2.0 — Filtering & Connections
+
+- **Time-range filters** — `since:` and `until:` arguments on `auditLogEntries`
+- **`touching:` filter** — narrow results to entries that changed a specific attribute
+- **Relay-style connection** — replace offset pagination with cursor-based `AuditLogEntryConnection` for forward/backward pagination
+- **Sorting** — `orderBy: { field: CREATED_AT, direction: DESC }`
+
+---
+
+## 0.3.0 — Actor & Resource Resolver Types
+
+- **`ActorType`** — resolve the polymorphic `actor` to the concrete type in the host app's schema (requires a configurable type resolver proc)
+- **`AuditedResourceType`** — resolve `item_type`/`item_id` to the concrete audited model type
+- **`diffType`** — structured `{ from, to }` diff type instead of raw `objectChanges` JSON
+
+---
+
+## 0.4.0 — Subscriptions
+
+Requires Action Cable in the host application.
+
+- **`auditLogEntryCreated(itemType:, itemId:)`** — subscribe to new entries for a specific record
+- **`auditLogEntryCreated(actorId:)`** — subscribe to all entries by a specific actor
+- Hooks into `RailsAuditLog::Streaming::NotificationsAdapter` to trigger broadcasts
+
+---
+
+## 0.5.0 — Multi-tenancy & Advanced Filtering
+
+- **Tenant scoping** — automatically scope queries via `RailsAuditLog.current_tenant` when configured
+- **`forTenant:` argument** — explicit tenant filter on `auditLogEntries`
+- **Aggregations** — `auditLogEntriesCount(event:, itemType:, since:)` for dashboard metrics
+
+---
+
+## 0.6.0 — Performance & Safety
+
+- **Dataloader batch loading** — batch-resolve polymorphic `actor` and `item` associations using graphql-ruby's `dataloader` to eliminate N+1 queries on list responses
+- **`auditLogReify` query** — `auditLogReify(itemType:, itemId:, at:)` returns the reconstructed object state as JSON at a given point in time, backed by `RailsAuditLog.version_at`
+- **Query complexity & depth limits** — built-in defaults (`max_complexity`, `max_depth`) with a config override (`RailsAuditLogGraphql.max_complexity = 200`) to protect against expensive queries before the API is declared stable
+- **`AuditLogJsonScalar`** — proper JSON scalar type for `objectChanges` and `metadata` fields, replacing opaque String serialization and making the schema self-documenting
+
+---
+
+## 1.0.0 — Stable API
+
+- Full YARD documentation
+- **RSpec matchers** — `expect(response).to have_graphql_audit_entry(:update).touching(:title)` 
+- **Minitest assertions** — `assert_graphql_audit_entry`
+- API stability guarantee — no breaking changes without a major version bump
+- Complete README with setup guide, examples, and schema reference

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "standard/rake"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:standard, :spec]

data/codecov.yml

@@ -0,0 +1,17 @@
+# Configure Pull Request Bot Comments
+comment:
+  layout: "reach, diff, flags, files"
+  behavior: default
+  # Only post or update the comment if the coverage drops
+  require_changes: "coverage_drop"
+
+# Configure Commit Status Checks (the green checkmark/red X list)
+coverage:
+  status:
+    project:
+      default:
+        # Prevent "Informational" mode so a drop causes an actual red failure check
+        informational: false
+    patch:
+      default:
+        informational: false

data/lib/generators/rails_audit_log/graphql/install/install_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RailsAuditLog
+  module Generators
+    module Graphql
+      class InstallGenerator < Rails::Generators::Base
+        source_root File.expand_path("templates", __dir__)
+        desc "Injects AuditLogEntriesQueryMixin into your GraphQL QueryType."
+
+        QUERY_TYPE_PATH = "app/graphql/types/query_type.rb"
+        MIXIN = "RailsAuditLog::Graphql::Queries::AuditLogEntriesQueryMixin"
+
+        def inject_mixin
+          if File.exist?(File.join(destination_root, QUERY_TYPE_PATH))
+            inject_into_file QUERY_TYPE_PATH,
+              "  include #{MIXIN}\n",
+              after: /class\s+\S+\s*<\s*\S+\s*\n/
+          else
+            say ""
+            say "#{QUERY_TYPE_PATH} not found. Add this line manually to your QueryType:", :yellow
+            say "  include #{MIXIN}", :green
+          end
+        end
+
+        def print_next_steps
+          say ""
+          say "Done! Your GraphQL API now has:", :green
+          say "  auditLogEntry(id: ID!): AuditLogEntry"
+          say "  auditLogEntries(...): [AuditLogEntry!]!"
+          say ""
+          say "See the README for full documentation."
+        end
+      end
+    end
+  end
+end

data/lib/rails_audit_log/graphql/queries/audit_log_entries_query_mixin.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RailsAuditLog
+  module Graphql
+    module Queries
+      module AuditLogEntriesQueryMixin
+        def self.included(base)
+          base.field(
+            :audit_log_entry,
+            RailsAuditLog::Graphql::Types::AuditLogEntryType,
+            null: true,
+            description: "Fetch a single audit log entry by ID. Returns nil if not found.",
+            resolver_method: :resolve_audit_log_entry
+          ) do
+            argument :id, GraphQL::Types::ID, required: true,
+              description: "ID of the audit log entry."
+          end
+
+          base.field(
+            :audit_log_entries,
+            [RailsAuditLog::Graphql::Types::AuditLogEntryType, null: false],
+            null: false,
+            description: "List audit log entries with optional filters. Offset-paginated.",
+            resolver_method: :resolve_audit_log_entries
+          ) do
+            argument :event, String, required: false, description: "Filter by event type (create, update, destroy)."
+            argument :item_type, String, required: false, description: "Filter by audited model class name."
+            argument :item_id, GraphQL::Types::ID, required: false, description: "Filter by audited record ID."
+            argument :actor_id, GraphQL::Types::ID, required: false, description: "Filter by actor ID."
+            argument :page, GraphQL::Types::Int, required: false, default_value: 1, description: "Page number (1-based)."
+            argument :per_page, GraphQL::Types::Int, required: false, default_value: 25, description: "Number of results per page."
+          end
+        end
+
+        def resolve_audit_log_entry(id:)
+          check_authentication!
+          RailsAuditLog::AuditLogEntry.find_by(id: id)
+        end
+
+        def resolve_audit_log_entries(event: nil, item_type: nil, item_id: nil, actor_id: nil, page: 1, per_page: 25)
+          check_authentication!
+          scope = RailsAuditLog::AuditLogEntry.order(created_at: :desc)
+          scope = scope.where(event: event) if event
+          scope = scope.where(item_type: item_type) if item_type
+          scope = scope.where(item_id: item_id) if item_id
+          scope = scope.where(actor_id: actor_id) if actor_id
+          scope.limit(per_page).offset((page - 1) * per_page)
+        end
+
+        private
+
+        def check_authentication!
+          auth = RailsAuditLog.authenticate
+          return unless auth
+          raise GraphQL::ExecutionError, "Unauthorized" unless auth.call(context)
+        end
+      end
+    end
+  end
+end

data/lib/rails_audit_log/graphql/release_tooling.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "date"
+
+module RailsAuditLog
+  module Graphql
+    # @api private
+    module ReleaseTooling
+      module_function
+
+      VERSION_PATTERN = /VERSION = "[^"]+"/
+      SEMVER_PATTERN = /\A\d+\.\d+\.\d+(?:[-.][0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?\z/
+      UNRELEASED_HEADING = "## [Unreleased]"
+
+      def normalize_version(version)
+        normalized = version.to_s.sub(/\Av/, "")
+        raise ArgumentError, "version must look like x.y.z" unless normalized.match?(SEMVER_PATTERN)
+
+        normalized
+      end
+
+      def update_version_file(contents, version)
+        normalized = normalize_version(version)
+        raise ArgumentError, "version file does not define VERSION" unless contents.match?(VERSION_PATTERN)
+
+        contents.sub(VERSION_PATTERN, %(VERSION = "#{normalized}"))
+      end
+
+      def finalize_changelog(contents, version, date = Date.today)
+        normalized = normalize_version(version)
+        release_heading = "## [#{normalized}] - #{date.iso8601}"
+
+        raise ArgumentError, "CHANGELOG.md must contain an Unreleased heading" unless contents.include?(UNRELEASED_HEADING)
+
+        if contents.match?(/^## \[#{Regexp.escape(normalized)}\](?: - .+)?$/)
+          raise ArgumentError, "CHANGELOG.md already contains #{normalized}"
+        end
+
+        contents.sub(UNRELEASED_HEADING, "#{UNRELEASED_HEADING}\n\n#{release_heading}")
+      end
+
+      # Removes milestone sections from ROADMAP.md where all feature bullets
+      # have been implemented (i.e. no remaining "- **" bullet points).
+      def prune_roadmap(contents)
+        separator = "\n\n---\n\n"
+        sections = contents.split(separator)
+
+        pruned = sections.reject do |section|
+          next false unless section.lstrip.match?(/\A## \d+\.\d+\.\d+/)
+
+          !section.include?("- **")
+        end
+
+        pruned.join(separator)
+      end
+
+      def extract_release_notes(contents, version)
+        normalized = normalize_version(version)
+        lines = contents.lines
+        release_heading = /^## \[#{Regexp.escape(normalized)}\](?: - .+)?$/
+        start_index = lines.index { |line| line.match?(release_heading) }
+
+        raise ArgumentError, "CHANGELOG.md is missing release notes for #{normalized}" unless start_index
+
+        body = lines[(start_index + 1)..].take_while { |line| !line.start_with?("## [") }.join.strip
+        body = "- No changes listed." if body.empty?
+
+        <<~MARKDOWN
+          ## RailsAuditLog::Graphql #{normalized}
+
+          #{body}
+        MARKDOWN
+      end
+    end
+  end
+end

data/lib/rails_audit_log/graphql/types/audit_log_entry_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsAuditLog
+  module Graphql
+    module Types
+      class AuditLogEntryType < BaseObject
+        graphql_name "AuditLogEntry"
+        description "A single audited event on an ActiveRecord model."
+
+        field :id, GraphQL::Types::ID, null: false
+        field :event, String, null: false
+        field :item_type, String, null: false
+        field :item_id, GraphQL::Types::ID, null: false
+        field :object_changes, GraphQL::Types::JSON, null: true
+        field :object, GraphQL::Types::JSON, null: true, method_conflict_warning: false
+        field :metadata, GraphQL::Types::JSON, null: true
+        field :reason, String, null: true
+        field :whodunnit_snapshot, String, null: true
+        field :actor_type, String, null: true
+        field :actor_id, GraphQL::Types::ID, null: true
+        field :tenant_id, String, null: true
+        field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      end
+    end
+  end
+end

data/lib/rails_audit_log/graphql/types/base_object.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RailsAuditLog
+  module Graphql
+    module Types
+      class BaseObject < GraphQL::Schema::Object
+      end
+    end
+  end
+end

data/lib/rails_audit_log/graphql/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RailsAuditLog
+  module Graphql
+    VERSION = "0.1.0"
+  end
+end

data/lib/rails_audit_log/graphql.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "graphql"
+require_relative "graphql/version"
+require_relative "graphql/types/base_object"
+require_relative "graphql/types/audit_log_entry_type"
+require_relative "graphql/queries/audit_log_entries_query_mixin"
+
+module RailsAuditLog
+  module Graphql
+    class Error < StandardError; end
+  end
+end

data/sig/rails_audit_log/graphql.rbs

@@ -0,0 +1,32 @@
+module RailsAuditLog
+  module Graphql
+    VERSION: String
+
+    module Types
+      class BaseObject < GraphQL::Schema::Object
+      end
+
+      class AuditLogEntryType < BaseObject
+      end
+    end
+
+    module Generators
+      module Graphql
+        class InstallGenerator < ::Rails::Generators::Base
+          def inject_mixin: () -> void
+          def print_next_steps: () -> void
+        end
+      end
+    end
+
+    module Queries
+      module AuditLogEntriesQueryMixin
+        def self.included: (untyped base) -> void
+        def resolve_audit_log_entry: (id: String) -> untyped
+        def resolve_audit_log_entries: (?event: String?, ?item_type: String?, ?item_id: String?, ?actor_id: String?, ?page: Integer, ?per_page: Integer) -> untyped
+        private
+        def check_authentication!: () -> void
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: rails_audit_log-graphql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chuck Smith
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rails_audit_log
+  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: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: simplecov_json_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: Provides audit logging for GraphQL mutations and queries in Rails applications.
+email:
+- chuck@eclecticcoding.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- CONTRIBUTING.md
+- LICENSE.txt
+- README.md
+- ROADMAP.md
+- Rakefile
+- codecov.yml
+- lib/generators/rails_audit_log/graphql/install/install_generator.rb
+- lib/rails_audit_log/graphql.rb
+- lib/rails_audit_log/graphql/queries/audit_log_entries_query_mixin.rb
+- lib/rails_audit_log/graphql/release_tooling.rb
+- lib/rails_audit_log/graphql/types/audit_log_entry_type.rb
+- lib/rails_audit_log/graphql/types/base_object.rb
+- lib/rails_audit_log/graphql/version.rb
+- sig/rails_audit_log/graphql.rbs
+homepage: https://github.com/eclectic-coding/rails_audit_log-graphql
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/eclectic-coding/rails_audit_log-graphql
+  source_code_uri: https://github.com/eclectic-coding/rails_audit_log-graphql
+  changelog_uri: https://github.com/eclectic-coding/rails_audit_log-graphql/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: GraphQL audit logging for Rails applications.
+test_files: []