zero_ruby

gem 'zero_ruby'

# app/zero/mutations/post_update.rb
module Mutations
  class PostUpdate < ApplicationMutation
    argument :id, Types::ID
    argument :post_input, Types::PostInput

    def execute(id:, post_input:)
      post = current_user.posts.find(id)
      authorize! post, to: :update?
      post.update!(**post_input)
    end
  end
end

# app/zero/app_schema.rb
# The mutation names should match the names used in your Zero client:
#   mutators.posts.update({ id: "...", post_input: { title: "..." } })
#   -> maps to "posts.update"
class ZeroSchema < ZeroRuby::Schema
  mutation "posts.update", handler: Mutations::PostUpdate
end

# app/controllers/zero_controller.rb
class ZeroController < ApplicationController
  # Skip CSRF for API endpoint
  # skip_before_action :verify_authenticity_token

  def mutate
    if request.get?
      # GET requests return TypeScript type definitions
      render plain: ZeroSchema.to_typescript, content_type: "text/plain; charset=utf-8"
    else
      # POST requests process mutations
      body = JSON.parse(request.body.read)

      # Build context hash. The gem reads three special keys:
      #   :current_user      - used to derive userID echoed in MutateResponse
      #   :user_id           - takes precedence over current_user when set
      #   :upstream_schema   - Postgres schema owned by zero-cache (?schema= param)
      # Everything else passes through verbatim as ctx[...] for your mutations.
      context = {
        current_user: current_user,
        upstream_schema: params[:schema]
      }

      result = ZeroSchema.execute(body, context: context)
      render json: result
    end
  rescue JSON::ParserError => e
    render json: {
      kind: "PushFailed",
      origin: "server",
      reason: "parse",
      message: "Invalid JSON: #{e.message}",
      mutationIDs: []
    }, status: :bad_request
  end
end

# config/routes.rb
# The path is up to you - point ZERO_MUTATE_URL at it.
match '/zero/mutate', to: 'zero#mutate', via: [:get, :post]

# app/zero/types/post_input.rb
module Types
  class PostInput < Types::BaseInputObject
    argument :title, Types::String.constrained(min_size: 1, max_size: 200)
    argument :body, Types::String.optional
    argument :published, Types::Boolean.default(false)
  end
end

# config/initializers/zero_ruby.rb
ZeroRuby.configure do |config|
  # Storage backend (:active_record is the only built-in option)
  config.lmid_store = :active_record

  # Retry attempts for transient errors (default: 1)
  config.max_retry_attempts = 1

  # Push protocol version (reject requests with different version)
  config.supported_push_version = 1
end

# Basic types
argument :name, Types::String
argument :count, Types::Integer
argument :price, Types::Float
argument :active, Types::Boolean
argument :id, Types::ID               # Non-empty string
argument :date, Types::ISO8601Date
argument :timestamp, Types::ISO8601DateTime

# Optional types (accepts nil)
argument :nickname, Types::String.optional

# Default values
argument :status, Types::String.default("draft")
argument :enabled, Types::Boolean.default(false)

# Length constraints
argument :title, Types::String.constrained(min_size: 1, max_size: 200)
argument :code, Types::String.constrained(size: 6)  # Exact size

# Numeric constraints
argument :age, Types::Integer.constrained(gt: 0, lt: 150)
argument :quantity, Types::Integer.constrained(gteq: 1, lteq: 100)

# Format (regex)
argument :slug, Types::String.constrained(format: /\A[a-z0-9-]+\z/)

# Inclusion
argument :status, Types::String.constrained(included_in: %w[draft published archived])

# Exclusion
argument :username, Types::String.constrained(excluded_from: %w[admin root system])

# Non-empty (filled)
argument :email, Types::String.constrained(filled: true)

# Combine constraints
argument :name, Types::String.constrained(min_size: 1, max_size: 100, format: /\A[a-zA-Z ]+\z/)

class PostUpdate < ApplicationMutation
  skip_auto_transaction

  argument :id, Types::ID
  argument :post_input, Types::PostInput

  def execute(id:, post_input:)
    # 1. Pre-transaction (LMID incremented on error)
    post = current_user.posts.find(id)
    authorize! post, to: :update?

    # 2. Transaction (Transaction rolled back, LMID incremented on error)
    transact do
      post.update!(**post_input)
    end

    # 3. Post-commit - only runs if transact succeeded
    NotificationService.notify_update(id)
  end
end

class PostCreate < ApplicationMutation
  argument :title, Types::String

  def execute(title:)
    if RateLimiter.exceeded?(current_user)
      raise ZeroRuby::Error.new(
        "Rate limit exceeded",
        details: {code: "RATE_LIMITED", retryAfter: 60}
      )
    end
    Post.create!(title: title, user: current_user)
  end
end