nohead 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b3b6ddca7dac0c2e2e1056aabba232a26b27fce7eae7eea1244519a88d0388fe
+  data.tar.gz: e9c0c92435a093999388ef2a84c73870c12dead425ada3c3bdf691c9fe993069
+SHA512:
+  metadata.gz: 3ab6ef2e8d3d027b07a2ff536cf3f14833970b4d80cbc51fcf2b65a3a10684012a4a1e70088b426e0c77a55927a21f2816d13991c869321bbdff84d705d30f8c
+  data.tar.gz: 2c73018868bc99808615f989f735149122b655705eac1f0af62a9bccfab465582857bbad1fb91a5f635230f2af272404f831d20e05f2387295ada5b901b0798a

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+Changes to the `nohead` gem that you can notice. Versions follow
+[Semantic Versioning](https://semver.org): additive API changes are minor
+releases; a change that could break your code is a major one. Each release's
+section is its GitHub release's notes.
+
+## 0.1.0
+
+The first release.
+
+- `Nohead::Client`, with methods for every operation an API key can call:
+  records (with revisions, scheduling, bulk changes and search),
+  collections, fields and migrations, assets, webhooks and their deliveries,
+  the audit log, feature flags.
+- Results you read with methods or `[]`, pages that are Enumerable across
+  every page, timestamps as Times.
+- Typed errors per API error type, retries with idempotency keys,
+  `if_match` and change notes.
+- `assets.upload` in one call (paths or IO), and webhook verification
+  (`Nohead::Webhooks.unwrap`). No runtime dependencies.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nohead
+
+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,298 @@
+# Nohead Ruby SDK
+
+The official Ruby client for the [Nohead](https://nohead.io) API: pages you can enumerate, retries that are safe for writes, one-call uploads and webhook verification. No runtime dependencies.
+
+```ruby
+require "nohead"
+
+nohead = Nohead::Client.new # reads NOHEAD_API_KEY
+
+nohead.records.list("posts", filter: { status: "published" }).each do |post|
+  puts post.data["title"]
+end
+```
+
+> **Status:** 0.x, not yet published to RubyGems. Until it is, use it from GitHub: `gem "nohead", github: "nohead-io/nohead-ruby"`.
+
+## Contents
+
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Records](#records)
+- [Pagination](#pagination)
+- [Errors](#errors)
+- [Retries and idempotency](#retries-and-idempotency)
+- [Concurrency](#concurrency)
+- [Assets](#assets)
+- [Search](#search)
+- [Schema](#schema)
+- [Webhooks](#webhooks)
+- [Results](#results)
+- [Reference](#reference)
+- [Development](#development)
+- [Releasing](#releasing)
+
+## Installation
+
+```ruby
+gem "nohead"
+```
+
+It needs Ruby 3.3 or newer. It uses only Ruby's standard library (Net::HTTP, JSON, OpenSSL). Use it on servers: API keys are secrets.
+
+## Configuration
+
+```ruby
+nohead = Nohead::Client.new(
+  api_key: ENV.fetch("NOHEAD_API_KEY"), # default: NOHEAD_API_KEY
+  base_url: "https://api.nohead.io" # default: NOHEAD_API_URL, else production
+)
+```
+
+| Option | Default | |
+|---|---|---|
+| `api_key:` | `NOHEAD_API_KEY` | A project API key (`sk_live_...`). Required. |
+| `base_url:` | `NOHEAD_API_URL`, else `https://api.nohead.io` | |
+| `project_id:` | the key's project | Looked up once with `GET /v1/me` when omitted. |
+| `max_retries:` | `2` | See [retries](#retries-and-idempotency). |
+| `timeout:` | `60` | Seconds per attempt. |
+| `headers:` | `{}` | Added to every request. |
+| `warnings:` | `true` | Warns about deprecated operations and plan usage, once each. |
+
+API keys belong to a project, so methods like `collections.list` need no project ID. Collections can be named by ID or slug everywhere.
+
+## Records
+
+```ruby
+draft = nohead.records.create("posts", data: { title: "Hello", author: "rec_01J9..." })
+post = nohead.records.get(draft.id, expand: ["author"])
+nohead.records.update(post.id, data: { title: "Hello again" }) # nil clears a field
+nohead.records.publish(post.id)
+nohead.records.schedule(post.id, unpublish_at: Time.utc(2027, 1, 1))
+nohead.records.delete(post.id) # soft delete; records.restore undoes it
+```
+
+Methods return the API's resources (see [Results](#results)) and raise on failure. Field values are under `data`, keyed by field API key.
+
+**More:**
+
+- `count`, and `bulk` (up to 100 records at once)
+- `diff(record, from_revision, to_revision)`
+- `revisions.list`, `revisions.get` and `revisions.revert` (with `dry_run: true` for a preview)
+
+## Pagination
+
+List methods return the first page, a `Nohead::Page`. It's Enumerable: `each`, `map`, `first` and so on walk every item across pages, fetching the next page only when needed.
+
+```ruby
+# Every record
+nohead.records.list("posts").each { |record| ... }
+nohead.records.list("posts").first(10) # fetches only what it needs
+
+# One page at a time
+page = nohead.records.list("posts", limit: 100)
+page.data # this page's records
+page.meta.next_cursor
+page = page.next_page while page.next_page?
+
+# Resume from a saved cursor
+nohead.records.list("posts", cursor: saved_cursor)
+```
+
+Filters are equality filters (for fields with several values: "contains"), and accept strings, numbers, booleans and Times:
+
+```ruby
+nohead.records.list("posts", filter: { status: "published", featured: true, author: "rec_01J9..." },
+                             sort: "-published_at", expand: %w[author tags])
+```
+
+## Errors
+
+Every error is a `Nohead::Error`. API errors are `Nohead::APIError`s with `status`, `type`, `message`, `request_id`, `details` and `headers`, in a class per type:
+
+| Class | Status |
+|---|---|
+| `InvalidRequestError` | 400 |
+| `AuthenticationError` | 401 |
+| `PlanLimitExceededError` | 402 |
+| `AuthorizationError` | 403 |
+| `NotFoundError` | 404 |
+| `ConflictError` | 409 |
+| `PreconditionFailedError` | 412 (`current_revision`) |
+| `ValidationError` | 422 |
+| `RateLimitError` | 429 (`retry_after`) |
+| `InternalServerError` | 500 and other 5xx |
+| `ServiceUnavailableError` | 503 |
+
+Other errors:
+
+- `Nohead::ConnectionError`, and `Nohead::TimeoutError`, which is a kind of `ConnectionError`
+- `Nohead::UploadError`
+- `Nohead::WebhookVerificationError`
+
+```ruby
+begin
+  nohead.records.create("posts", data: {})
+rescue Nohead::ValidationError => e
+  e.details.each { |detail| puts "#{detail.field}: #{detail.message}" }
+end
+```
+
+## Retries and idempotency
+
+Failed requests are retried twice by default (`max_retries:`), with exponential backoff:
+
+- what's retried: connection errors, timeouts, 429, 500, 502, 503, 504, and a 409 for a request that is still running
+- `Retry-After` is honored up to 60 seconds; a longer one raises `RateLimitError` straight away
+
+Every write gets an `Idempotency-Key` that stays the same across its retries, so a retry after a lost response never writes twice. To make a write safe across your own retries (a job that may run twice), pass a key:
+
+```ruby
+nohead.records.create("posts", data: data, idempotency_key: "import-#{row.id}")
+```
+
+Writes also take `change_note:`, a reason shown in history.
+
+## Concurrency
+
+Pass the revision you read to make sure nobody changed the record since:
+
+```ruby
+post = nohead.records.get(id)
+begin
+  nohead.records.update(id, data: { title: title }, if_match: post)
+rescue Nohead::PreconditionFailedError => e
+  # changed since (now at e.current_revision): reload, and merge or ask
+end
+```
+
+`if_match:` takes a record or a revision number, on `update`, `delete`, `publish`, `unpublish` and `revisions.revert`.
+
+## Assets
+
+```ruby
+asset = nohead.assets.upload("cover.jpg")
+nohead.records.update(id, data: { cover: asset.id })
+
+url = nohead.assets.image_url(asset.id, width: 1200, format: "webp").url
+```
+
+**What `upload` accepts:** a path (String or Pathname), or an IO opened in binary mode. For bytes in memory, pass `StringIO.new(bytes)`.
+
+**What it does:**
+
+1. Creates the upload.
+2. Streams the bytes straight to storage.
+3. Completes the upload, which checks the file, and returns the `ready` asset.
+
+**Errors:** `UploadError` if storage refuses the bytes; `ValidationError` if the file fails the checks.
+
+**Uploading from a browser:** create the upload on your server with `create_upload`, `PUT` the file from the browser, then `complete` it.
+
+## Search
+
+```ruby
+# One collection
+nohead.records.search("posts", "content model").each { |hit| ... }
+
+# Across the project
+results = nohead.search("content model", collections: %w[posts pages])
+results.meta.total_estimate
+```
+
+Search needs `search_enabled` collections and the `search:read` scope. It pages through the first 1,000 hits.
+
+## Schema
+
+```ruby
+nohead.collections.create(name: "Posts", slug: "posts",
+                          fields: [{ name: "Title", api_key: "title", type: "text", required: true }])
+nohead.fields.create("posts", name: "Summary", api_key: "summary", type: "long_text")
+
+# Changes that rewrite records go through a migration; preview first
+preview = nohead.fields.migrate("fld_...", type: "long_text", dry_run: true)
+migration = nohead.fields.migrate("fld_...", type: "long_text")
+nohead.migrations.get(migration.id)
+```
+
+For schema as code, see the `nohead` CLI (`nohead schema pull/diff/push`).
+
+## Webhooks
+
+Verify a webhook request, then use its event:
+
+```ruby
+# e.g. in a Rails controller
+event = Nohead::Webhooks.unwrap(request.raw_post, request.headers,
+                                secret: ENV.fetch("NOHEAD_WEBHOOK_SECRET"))
+if event.type == "record.published"
+  RebuildJob.perform_later(event.data.record.collection)
+end
+head :no_content
+```
+
+`unwrap` checks the signature and the timestamp (Standard Webhooks), and raises `Nohead::WebhookVerificationError` if either is off. Pass the raw body: parsing and re-serializing JSON changes the bytes.
+
+It's also available as `nohead.webhooks.unwrap` on a client. Events can arrive more than once, so deduplicate by the `webhook-id` header.
+
+## Results
+
+The API's resources come back as `Nohead::NoheadObject`s.
+
+- **Reading fields:** use methods (`record.data`) or `[]` (`record[:data]`, `record["data"]`), at any depth.
+- **Fields named like Ruby's own methods** (`method`, `hash`…) need `[]`.
+- **Timestamps** (`*_at`) are `Time`s.
+- **Unknown fields are kept**, because the API adds fields and values without notice.
+- **`to_h`** gives the raw Hash.
+
+## Reference
+
+| Resource | Methods |
+|---|---|
+| `records` | `list`, `get`, `create`, `update`, `delete`, `restore`, `publish`, `unpublish`, `schedule`, `unschedule`, `count`, `bulk`, `diff`, `search` |
+| `records.revisions` | `list`, `get`, `revert` |
+| `search` | across the project |
+| `collections` | `list`, `get`, `create`, `update`, `delete`, `restore`, `schema` |
+| `collections.schema_changes` | `list`, `get` |
+| `collections.search_index` | `get`, `rebuild` |
+| `fields` | `list`, `create`, `update`, `delete`, `restore`, `reorder`, `remove_alias`, `migrate` |
+| `migrations` | `list`, `get`, `cancel` |
+| `assets` | `upload`, `create_upload`, `complete`, `list`, `get`, `delete`, `restore`, `image_url`, `download_url` |
+| `webhooks` | `list`, `get`, `create`, `update`, `delete`, `rotate_secret`, `test`, `unwrap` |
+| `webhooks.deliveries` | `list`, `get`, `retry` |
+| `audit_events` | `list` |
+| `feature_flags` | `list` |
+| `me` | `get` |
+| `health` | `check` |
+
+The SDK covers every operation an API key can call. Organizations, projects, members and API keys are managed in the web app. The full API is documented at [docs.nohead.io](https://docs.nohead.io).
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test       # unit and contract tests
+bundle exec rubocop
+bundle exec rake generate   # after updating openapi.json
+bundle exec rake samples    # after changing test/calls.rb (the docs' code samples)
+```
+
+**How the code is organized:**
+
+- `openapi.json` is the API's published contract. `rake generate` derives the operation table, `lib/nohead/operations.rb`, from it.
+- The methods are written by hand.
+- `test/contract_test.rb` runs every call in `test/calls.rb`. It fails when an API-key operation in the contract has no method, or when a request doesn't match its operation.
+
+The smoke test (`smoke/smoke.rb`) runs the core flow against a real API, with the gem as installed from its built package. Nohead's own CI runs it on every API contract change.
+
+## Releasing
+
+1. Bump `lib/nohead/version.rb`.
+2. Add a section for the version to `CHANGELOG.md` (`## 1.2.3`), which becomes the release's notes.
+3. Merge to `main`. Its ruleset requires the **CI passed** check, so the commit goes through a pull request or a branch whose CI passed, and force pushes are refused.
+4. Run the **SDK release** workflow in the Nohead API repository. It runs this commit's smoke test against the API and pushes the tag `v1.2.3`. Nobody else can push `v*` tags: a tag ruleset lets only that workflow's deploy key through.
+5. The tag starts `.github/workflows/release.yml`. Its publishing job runs in the `release` environment, which only `v*` tags can use, and the registry's trusted publisher accepts only that environment. It checks the version and its notes, tests, and pushes the gem to RubyGems through trusted publishing (no API key, with an attestation). Then it creates the GitHub release.
+
+## License
+
+MIT

data/lib/nohead/client.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "time"
+require "uri"
+
+module Nohead
+  # A client for the Nohead API, authenticated with a project API key.
+  #
+  #   nohead = Nohead::Client.new # NOHEAD_API_KEY
+  #   nohead.records.list("posts").each { |post| puts post.data["title"] }
+  class Client
+    DEFAULT_BASE_URL = "https://api.nohead.io"
+    RETRYABLE_STATUSES = [429, 500, 502, 503, 504].freeze
+    MAX_RETRY_AFTER = 60
+
+    attr_reader :records, :collections, :fields, :migrations, :assets, :webhooks,
+                :audit_events, :feature_flags, :me, :health
+
+    # api_key::     A project API key ("sk_live_..."). Defaults to NOHEAD_API_KEY.
+    # base_url::    Defaults to NOHEAD_API_URL, else https://api.nohead.io.
+    # project_id::  The key's project. Looked up once with GET /v1/me when omitted.
+    # max_retries:: Retries of failed requests (see the README, "Retries").
+    # timeout::     Seconds per attempt.
+    # headers::     Headers added to every request.
+    # warnings::    Warn about deprecated operations and plan usage (once each).
+    def initialize(api_key: nil, base_url: nil, project_id: nil, max_retries: 2, timeout: 60,
+                   headers: {}, warnings: true, transport: Transport.new)
+      @api_key = present(api_key) || present(ENV.fetch("NOHEAD_API_KEY", nil)) or
+        raise Error, "Missing API key: pass api_key or set NOHEAD_API_KEY"
+      @base_url = (present(base_url) || present(ENV.fetch("NOHEAD_API_URL", nil)) ||
+                   DEFAULT_BASE_URL).chomp("/")
+      @project_id = project_id
+      @max_retries = max_retries
+      @timeout = timeout
+      @headers = headers.to_h { |key, value| [key.to_s, value.to_s] }
+      @warnings = warnings
+      @transport = transport
+      @warned = {}
+
+      @records = Resources::Records.new(self)
+      @collections = Resources::Collections.new(self)
+      @fields = Resources::Fields.new(self)
+      @migrations = Resources::Migrations.new(self)
+      @assets = Resources::Assets.new(self)
+      @webhooks = Resources::Webhooks.new(self)
+      @audit_events = Resources::AuditEvents.new(self)
+      @feature_flags = Resources::FeatureFlags.new(self)
+      @me = Resources::Me.new(self)
+      @health = Resources::Health.new(self)
+    end
+
+    # Full-text search across the key's project (or some of its collections),
+    # most relevant first, through the first 1,000 hits.
+    def search(query, collections: nil, status: nil, limit: nil, cursor: nil)
+      paginate("projects_search", query: {
+                 q: query, collections: collections, filter: { status: status }, limit: limit,
+                 cursor: cursor
+               })
+    end
+
+    # The API key's project, from GET /v1/me the first time.
+    def project_id
+      @project_id ||= begin
+        me = request("me_get")
+        me.api_key or raise Error, "The credentials are not a project API key"
+        me.api_key.project_id
+      end
+    end
+
+    # Sends one operation (as listed in Nohead::OPERATIONS) and returns its
+    # result. The resources call this; it is public for operations the SDK
+    # does not wrap yet.
+    def request(operation, path: {}, query: {}, body: nil, idempotency_key: nil,
+                change_note: nil, if_match: nil)
+      NoheadObject.wrap(send_request(operation, path: path, query: query, body: body,
+                                                idempotency_key: idempotency_key,
+                                                change_note: change_note, if_match: if_match))
+    end
+
+    # A list operation as a Page that fetches the following pages as needed.
+    def paginate(operation, path: {}, query: {})
+      params = query.dup
+      cursor = params.delete(:cursor)
+      fetch = lambda do |next_cursor|
+        list = send_request(operation, path: path, query: params.merge(cursor: next_cursor))
+        Page.new(NoheadObject.wrap(list.fetch("data")), NoheadObject.wrap(list.fetch("meta")),
+                 &fetch)
+      end
+      fetch.call(cursor)
+    end
+
+    # Sends a file to a presigned storage URL (no API credentials).
+    def put_upload(url, method, headers, source)
+      retries = source.replayable? ? @max_retries : 0
+      attempt = 0
+      loop do
+        begin
+          response = @transport.call(method, url,
+                                     headers.merge("Content-Length" => source.byte_size.to_s),
+                                     source.io, @timeout)
+          return response unless RETRYABLE_STATUSES.include?(response.status) && attempt < retries
+        rescue ConnectionError
+          raise if attempt >= retries
+        end
+        pause(backoff(attempt))
+        attempt += 1
+        source.rewind
+      end
+    end
+
+    def inspect = "#<Nohead::Client #{@base_url}>"
+
+    private
+
+    def send_request(operation, path: {}, query: {}, body: nil, idempotency_key: nil,
+                     change_note: nil, if_match: nil)
+      method, template = OPERATIONS.fetch(operation)
+      url = build_url(template, path) + query_string(query)
+      headers = request_headers(method, body, idempotency_key, change_note, if_match)
+      payload = body.nil? ? nil : JSON.generate(json_ready(body))
+      attempt = 0
+      loop do
+        begin
+          response = @transport.call(method, url, headers, payload, @timeout)
+        rescue ConnectionError
+          raise if attempt >= @max_retries
+
+          pause(backoff(attempt))
+          attempt += 1
+          next
+        end
+
+        warn_about(operation, response.headers)
+        parsed = parse(response)
+        return parsed if response.status.between?(200, 299)
+
+        error = Nohead.api_error(response.status, parsed, response.headers)
+        delay = retry_delay(error, attempt)
+        raise error if delay.nil?
+
+        pause(delay)
+        attempt += 1
+      end
+    end
+
+    def build_url(template, values)
+      values = values.transform_keys(&:to_s)
+      values["project_id"] ||= project_id if template.include?("{project_id}")
+      path = template.gsub(/\{(\w+)\}/) do
+        value = values[Regexp.last_match(1)]
+        raise Error, "Missing #{Regexp.last_match(1)}" if value.nil? || value.to_s.empty?
+
+        URI.encode_www_form_component(value.to_s).gsub("+", "%20")
+      end
+      @base_url + path
+    end
+
+    # Query parameters as the API reads them: hashes become key[sub]=...
+    # (filter[status]=published), arrays are comma-separated (expand=author,tags),
+    # times are ISO 8601. nil values are left out.
+    def query_string(params)
+      pairs = []
+      add = lambda do |key, value|
+        case value
+        when nil then nil
+        when Hash then value.each { |name, inner| add.call("#{key}[#{name}]", inner) }
+        when Array
+          items = value.compact.map { |item| scalar(item) }
+          pairs << [key, items.join(",")] unless items.empty?
+        else pairs << [key, scalar(value)]
+        end
+      end
+      params.each { |key, value| add.call(key.to_s, value) }
+      pairs.empty? ? "" : "?#{URI.encode_www_form(pairs)}"
+    end
+
+    def scalar(value)
+      case value
+      when Time, DateTime then value.to_time.utc.iso8601(3)
+      when Date then value.iso8601
+      else value.to_s
+      end
+    end
+
+    def json_ready(value)
+      case value
+      when Hash then value.to_h { |key, inner| [key.to_s, json_ready(inner)] }
+      when Array then value.map { |item| json_ready(item) }
+      when Time, DateTime then value.to_time.utc.iso8601(3)
+      when Date then value.iso8601
+      when Symbol then value.to_s
+      else value
+      end
+    end
+
+    def request_headers(method, body, idempotency_key, change_note, if_match)
+      headers = {
+        "Accept" => "application/json",
+        "Authorization" => "Bearer #{@api_key}",
+        "Nohead-Client" => "sdk-ruby/#{VERSION}",
+        "User-Agent" => "nohead-ruby/#{VERSION} ruby/#{RUBY_VERSION}"
+      }.merge(@headers)
+      headers["Content-Type"] = "application/json" unless body.nil?
+      headers["Idempotency-Key"] = idempotency_key || SecureRandom.uuid unless method == "GET"
+      unless if_match.nil?
+        revision = if_match.respond_to?(:revision) ? if_match.revision : if_match
+        headers["If-Match"] = %("#{revision}")
+      end
+      headers["Nohead-Change-Note"] = change_note if change_note
+      headers
+    end
+
+    def parse(response)
+      return nil if response.body.nil? || response.body.empty?
+      return response.body unless response.headers["content-type"].to_s.include?("json")
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      response.body
+    end
+
+    # Seconds to wait before retrying `error`, or nil to raise it.
+    def retry_delay(error, attempt)
+      return nil if attempt >= @max_retries
+
+      in_progress = error.status == 409 && error.details.any? { |d| d["code"] == "in_progress" }
+      return nil unless in_progress || RETRYABLE_STATUSES.include?(error.status)
+
+      retry_after = Nohead.retry_after_seconds(error.headers)
+      return backoff(attempt) if retry_after.nil?
+
+      retry_after <= MAX_RETRY_AFTER ? retry_after : nil
+    end
+
+    # Exponential backoff with jitter: about 0.5 s, 1 s, 2 s... up to 8 s.
+    def backoff(attempt)
+      [0.5 * (2**attempt), 8.0].min * (1 - (rand * 0.25))
+    end
+
+    def pause(seconds)
+      sleep(seconds) if seconds.positive?
+    end
+
+    def warn_about(operation, headers)
+      return unless @warnings
+
+      if headers["deprecation"] && !@warned[operation]
+        @warned[operation] = true
+        sunset = headers["sunset"] ? " and will be removed after #{headers['sunset']}" : ""
+        link = headers["link"].to_s[/<([^>]+)>/, 1]
+        warn "[nohead] #{operation} is deprecated#{sunset}#{". See #{link}" if link}"
+      end
+      return unless headers["nohead-usage-warning"] && !@warned[:usage]
+
+      @warned[:usage] = true
+      warn "[nohead] Over a plan limit: #{headers['nohead-usage-warning']}"
+    end
+
+    def present(value)
+      value.nil? || value.to_s.empty? ? nil : value
+    end
+  end
+end