easydocforms 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8579650e0df3df94f0102fb155b27ff8085cbe2739ba087446dd26bbd872239
+  data.tar.gz: cdbb3095f0d0ede335a3f531dc47c98d0c0b758e00b4322a30371e31e7c56778
+SHA512:
+  metadata.gz: b5d2fa258cd32821ab501c0eade49587e7b97b2dca1ed9dd8e71ff0f09af1682e6edb1cf692c454676056e260121e2c2c13ff5bc435570899e72033eaa039f25
+  data.tar.gz: 5f0244065924672668c3462488d1dc20e796a264ceb1de041c83590ebec9ef106f4bed699690873e0464dbccc2d6aecd3b63ae31b1b1192d69078f393c15bdc6

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+Initial release.
+
+- `EasyDocForms::Client` covering every Partner API v1 operation: ping,
+  imports (create / get / wait), templates, fill links, submissions
+  (get / download PDF / signed pdf-link), webhooks (create / list / delete /
+  test).
+- `EasyDocForms::Webhook.verify!` / `.construct_event` implementing the
+  `X-EDF-Signature` contract: HMAC-SHA256 over the raw body, constant-time
+  compare, ±5 minute replay tolerance.
+- Typed errors: `AuthenticationError`, `PermissionError`, `NotFoundError`,
+  `PDFPendingError`, `RateLimitError`.
+- `rails generate easydocforms:webhook` — a verified receiver controller.
+- Zero runtime dependencies.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EasyDocForms (easydocforms.com)
+
+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,127 @@
+# easydocforms
+
+[![Gem Version](https://badge.fury.io/rb/easydocforms.svg)](https://rubygems.org/gems/easydocforms)
+[![CI](https://github.com/easydocforms/easydocforms-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/easydocforms/easydocforms-ruby/actions/workflows/ci.yml)
+
+The official Ruby SDK for the [EasyDocForms](https://easydocforms.com) Partner API.
+
+EasyDocForms turns a blank PDF intake form into a hosted, mobile-friendly fillable form — and returns the completed, pixel-exact PDF plus structured JSON answers. The API wraps the same document-understanding pipeline EasyDocForms runs in production for healthcare intake: import a blank PDF, wait for the template, mint a hosted fill link, hand it to a patient, then retrieve the results.
+
+**Zero runtime dependencies** — standard library only (`net/http`, `json`, `openssl`).
+
+- API reference: <https://easydocforms.com/docs/api>
+
+## Install
+
+```ruby
+# Gemfile
+gem "easydocforms"
+```
+
+## Quickstart
+
+API keys are created in the EasyDocForms app under **Settings → Integrations → Partner API** (shown exactly once).
+
+```ruby
+require "easydocforms"
+
+client = EasyDocForms::Client.new(ENV["EASYDOCFORMS_API_KEY"])
+pong = client.ping
+puts "org #{pong[:org_id]}, key #{pong[:key_name]}, scopes #{pong[:scopes].join(", ")}"
+```
+
+## The full loop
+
+```ruby
+# 1. Import a blank PDF (async — returns immediately).
+import = client.create_import(
+  pdf_url: "https://example.com/new-patient-intake.pdf",
+  filename: "new-patient-intake.pdf",
+  blank_form_attestation: true # you attest the PDF is a blank template — no PHI
+)
+
+# 2. Wait for processing (typically 1–10 minutes). Imports never fail for
+# quality reasons: the template is always created, and :review_required tells
+# your staff what to double-check in the EasyDocForms editor.
+import = client.wait_for_import(import[:import_id])
+raise import[:error] if import[:status] == "failed"
+
+# 3. Mint a hosted fill link and hand it to the patient. No EasyDocForms
+# account needed on their side.
+link = client.create_fill_link(
+  template_id: import[:template_id],
+  external_ref: "visit-8675309" # your correlation id — must not contain PHI
+)
+puts "send the patient to: #{link[:url]}"
+
+# 4. When the patient submits (see webhooks below), fetch the results.
+submission = client.get_submission(submission_id)
+submission[:answers] # => { field_id => value, ... }
+
+File.binwrite("completed.pdf", client.download_submission_pdf(submission_id))
+
+# Or get a ~10-minute signed URL that needs no Authorization header — safe to
+# hand to a browser or EMR without embedding your API key.
+begin
+  pdf_link = client.get_submission_pdf_link(submission_id)
+rescue EasyDocForms::PDFPendingError
+  # The frozen artifact isn't ready yet; use download_submission_pdf instead.
+end
+```
+
+## Webhooks
+
+Register a delivery URL, store the one-time `whsec_*` secret, and verify every delivery's `X-EDF-Signature` header against the **raw** request body:
+
+```ruby
+result = client.create_webhook(url: "https://your-app.example.com/webhooks/easydocforms")
+result[:secret] # shown only once — store it now
+```
+
+```ruby
+event = EasyDocForms::Webhook.construct_event(
+  payload: request.body.read,
+  header:  request.headers[EasyDocForms::Webhook::HEADER],
+  secret:  ENV["EASYDOCFORMS_WEBHOOK_SECRET"]
+)
+
+case event[:event]
+when "submission.created"
+  # PHI-minimized: no answers in the payload. Fetch them with your API key
+  # via event[:data][:submission_id].
+end
+```
+
+Verification recomputes an HMAC-SHA256 over the raw body, compares in constant time, and rejects timestamps more than 5 minutes from now (configurable via `tolerance:`). A failed check raises `EasyDocForms::SignatureVerificationError` — respond `400` and move on.
+
+### Rails
+
+```sh
+rails generate easydocforms:webhook
+```
+
+creates a verified receiver controller at `app/controllers/easydocforms_webhooks_controller.rb` and prints the route + credentials setup.
+
+## Error handling
+
+API failures raise typed subclasses of `EasyDocForms::APIError`, each carrying `status_code`, the server's message, and a machine-readable `code` on authorization failures:
+
+| Error | When |
+|---|---|
+| `AuthenticationError` | 401 — missing, invalid, or revoked key |
+| `PermissionError` | 403 — `code` is `SCOPE_REQUIRED` or `PARTNER_API_NOT_ENABLED` |
+| `NotFoundError` | 404 — no such resource in your organization |
+| `PDFPendingError` | 409 on `get_submission_pdf_link` — fall back to `download_submission_pdf` |
+| `RateLimitError` | 429 — back off and retry |
+
+The SDK does not retry automatically.
+
+## PHI boundary
+
+- **Imports are blank forms only.** Every import requires `blank_form_attestation: true`, asserting the PDF contains no patient-identifiable information.
+- **`external_ref` must never contain PHI.** It is an opaque correlation id echoed on submissions and webhook events.
+- **Webhook payloads are PHI-minimized by design** — ids and retrieve URLs, never patient answers. Answers are only available over the authenticated API.
+
+## License
+
+MIT

data/lib/easydocforms/client.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module EasyDocForms
+  # Client for the EasyDocForms Partner API. Thread-safe; standard library
+  # only.
+  #
+  #   client = EasyDocForms::Client.new("edfk_live_...")
+  #   client.ping # => { org_id: "...", key_name: "...", scopes: [...] }
+  #
+  # All methods return Hashes with symbol keys, shaped exactly like the API's
+  # JSON (see https://easydocforms.com/docs/api). API failures raise
+  # EasyDocForms::APIError subclasses.
+  class Client
+    USER_AGENT = "easydocforms-ruby/#{VERSION}"
+
+    # @param api_key [String] an edfk_live_* key, created in the EasyDocForms
+    #   app under Settings → Integrations → Partner API (shown exactly once).
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, open_timeout: 10, read_timeout: 60)
+      raise ArgumentError, "api_key is required" if api_key.to_s.empty?
+
+      @api_key = api_key
+      @base_url = base_url.sub(%r{/+\z}, "")
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+    end
+
+    # Proves the key authenticates, names its organization, and echoes its
+    # scopes. Requires no scope.
+    def ping
+      request(:get, "/ping")
+    end
+
+    # Imports a blank PDF (async; scope imports:write). Supply exactly one of
+    # +pdf_url+ (public HTTPS) or +pdf_base64+. +blank_form_attestation+ must
+    # be true: you attest the PDF is a blank template with no patient
+    # information (PHI). Returns { import_id:, status: "queued" } immediately;
+    # processing typically takes 1–10 minutes.
+    def create_import(filename:, blank_form_attestation:, pdf_url: nil, pdf_base64: nil, title: nil)
+      request(:post, "/imports", body: {
+        pdf_url: pdf_url,
+        pdf_base64: pdf_base64,
+        filename: filename,
+        title: title,
+        blank_form_attestation: blank_form_attestation
+      })
+    end
+
+    # Polls an import job (scope imports:write). Result fields appear when
+    # +:status+ is "succeeded"; +:error+ when "failed".
+    def get_import(import_id)
+      request(:get, "/imports/#{encode(import_id)}")
+    end
+
+    # Polls #get_import until the job reaches a terminal status ("succeeded"
+    # or "failed") and returns it — a failed import is returned, not raised.
+    # Raises EasyDocForms::Error after +timeout+ seconds.
+    def wait_for_import(import_id, poll_interval: 5, timeout: 900)
+      deadline = Time.now + timeout
+      loop do
+        import = get_import(import_id)
+        return import if %w[succeeded failed].include?(import[:status])
+        raise Error, "timed out after #{timeout}s waiting for import #{import_id}" if Time.now >= deadline
+
+        sleep(poll_interval)
+      end
+    end
+
+    # The organization's active templates, newest first (scope
+    # templates:read). Returns the array of template hashes.
+    def list_templates
+      request(:get, "/templates").fetch(:templates)
+    end
+
+    # Mints a hosted URL where a patient fills the form (scope
+    # fill_links:write). +external_ref+ is an opaque correlation id echoed on
+    # submissions and webhooks — it must never contain PHI.
+    def create_fill_link(template_id:, expires_in_days: nil, max_responses: nil, external_ref: nil)
+      request(:post, "/fill-links", body: {
+        template_id: template_id,
+        expires_in_days: expires_in_days,
+        max_responses: max_responses,
+        external_ref: external_ref
+      })
+    end
+
+    # A patient submission: structured +:answers+ plus correlation back to the
+    # fill link that produced it (scope submissions:read).
+    def get_submission(submission_id)
+      request(:get, "/submissions/#{encode(submission_id)}")
+    end
+
+    # The completed, pixel-exact PDF as a binary string (scope
+    # submissions:read). Works even while +completed_pdf_status+ is "pending"
+    # (renders on demand — just slower).
+    def download_submission_pdf(submission_id)
+      request(:get, "/submissions/#{encode(submission_id)}/pdf", raw: true)
+    end
+
+    # A time-limited signed URL (~10 minutes) that downloads the completed PDF
+    # without any Authorization header (scope submissions:read) — safe to hand
+    # onward without embedding your API key. Raises
+    # EasyDocForms::PDFPendingError while the frozen artifact isn't ready;
+    # fall back to #download_submission_pdf.
+    def get_submission_pdf_link(submission_id)
+      request(:get, "/submissions/#{encode(submission_id)}/pdf-link")
+    end
+
+    # Registers a webhook delivery URL (scope webhooks:manage). The returned
+    # +:secret+ (whsec_*) is shown exactly once — store it; it verifies the
+    # X-EDF-Signature header (see EasyDocForms::Webhook). +events+ filters
+    # deliveries; nil or empty = all events.
+    def create_webhook(url:, events: nil)
+      request(:post, "/webhooks", body: { url: url, events: events })
+    end
+
+    # Active subscriptions, newest first, without secrets (scope
+    # webhooks:manage). Returns the array of webhook hashes.
+    def list_webhooks
+      request(:get, "/webhooks").fetch(:webhooks)
+    end
+
+    # Deactivates a subscription (scope webhooks:manage).
+    def delete_webhook(webhook_id)
+      request(:delete, "/webhooks/#{encode(webhook_id)}")
+    end
+
+    # Synchronously delivers one signed test event so you can verify your
+    # receiver end to end (scope webhooks:manage). Returns
+    # { delivered:, status_code: } — delivery failure is reported there, not
+    # raised.
+    def test_webhook(webhook_id)
+      request(:post, "/webhooks/#{encode(webhook_id)}/test")
+    end
+
+    private
+
+    def encode(id)
+      URI.encode_uri_component(id.to_s)
+    end
+
+    def request(method, path, body: nil, raw: false)
+      uri = URI.parse(@base_url + path)
+      req = build_request(method, uri, body, raw)
+      res = Net::HTTP.start(
+        uri.host, uri.port,
+        use_ssl: uri.scheme == "https",
+        open_timeout: @open_timeout, read_timeout: @read_timeout
+      ) { |http| http.request(req) }
+
+      status = res.code.to_i
+      raise APIError.from_response(status, res.body) unless (200..299).cover?(status)
+      return res.body if raw
+
+      JSON.parse(res.body, symbolize_names: true)
+    end
+
+    def build_request(method, uri, body, raw)
+      req =
+        case method
+        when :get then Net::HTTP::Get.new(uri)
+        when :post then Net::HTTP::Post.new(uri)
+        when :delete then Net::HTTP::Delete.new(uri)
+        else raise ArgumentError, "unsupported method #{method}"
+        end
+      req["Authorization"] = "Bearer #{@api_key}"
+      req["User-Agent"] = USER_AGENT
+      req["Accept"] = raw ? "application/pdf" : "application/json"
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body.compact)
+      end
+      req
+    end
+  end
+end

data/lib/easydocforms/errors.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module EasyDocForms
+  # Base class for every error this gem raises.
+  class Error < StandardError; end
+
+  # Raised when a webhook delivery fails signature verification.
+  class SignatureVerificationError < Error; end
+
+  # An API-level failure: the request reached EasyDocForms and was rejected.
+  # Transport failures raise their ordinary Ruby exceptions instead.
+  class APIError < Error
+    # Machine-readable codes on authorization failures.
+    PARTNER_API_NOT_ENABLED = "PARTNER_API_NOT_ENABLED"
+    SCOPE_REQUIRED          = "SCOPE_REQUIRED"
+
+    attr_reader :status_code, :code, :hint, :completed_pdf_status
+
+    def initialize(message, status_code:, code: nil, hint: nil, completed_pdf_status: nil)
+      super(message)
+      @status_code = status_code
+      @code = code
+      @hint = hint
+      @completed_pdf_status = completed_pdf_status
+    end
+
+    # Builds the right error subclass from an HTTP error response.
+    def self.from_response(status_code, body)
+      parsed = begin
+        JSON.parse(body.to_s)
+      rescue JSON::ParserError
+        {}
+      end
+      parsed = {} unless parsed.is_a?(Hash)
+      message = parsed["error"] || "HTTP #{status_code}"
+      attrs = {
+        status_code: status_code,
+        code: parsed["code"],
+        hint: parsed["hint"],
+        completed_pdf_status: parsed["completed_pdf_status"]
+      }
+      klass =
+        case status_code
+        when 401 then AuthenticationError
+        when 403 then PermissionError
+        when 404 then NotFoundError
+        when 409 then parsed["completed_pdf_status"] == "pending" ? PDFPendingError : APIError
+        when 429 then RateLimitError
+        else APIError
+        end
+      klass.new(message, **attrs)
+    end
+  end
+
+  # 401: missing, invalid, or revoked API key.
+  class AuthenticationError < APIError; end
+
+  # 403: the key authenticated but may not do this — +code+ is
+  # SCOPE_REQUIRED (key lacks the route's scope) or PARTNER_API_NOT_ENABLED
+  # (organization not enrolled in the partner API).
+  class PermissionError < APIError; end
+
+  # 404: no such resource in your organization.
+  class NotFoundError < APIError; end
+
+  # 409 on submission_pdf_link: the frozen completed PDF is not available
+  # (yet). Fall back to Client#download_submission_pdf, which renders on
+  # demand.
+  class PDFPendingError < APIError; end
+
+  # 429: rate limited — back off and retry.
+  class RateLimitError < APIError; end
+end

data/lib/easydocforms/version.rb

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

data/lib/easydocforms/webhook.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+
+module EasyDocForms
+  # Verifies webhook deliveries against a subscription's whsec_* secret
+  # (returned once by Client#create_webhook).
+  #
+  # Every delivery is signed:
+  #
+  #   X-EDF-Signature: t=<unix>,v1=<hex hmac-sha256(secret, "<t>.<raw body>")>
+  #
+  # Verify over the RAW request body, before any JSON parsing:
+  #
+  #   event = EasyDocForms::Webhook.construct_event(
+  #     payload: request.body.read,
+  #     header:  request.headers["X-EDF-Signature"],
+  #     secret:  ENV["EASYDOCFORMS_WEBHOOK_SECRET"]
+  #   )
+  #   case event[:event]
+  #   when "submission.created" then ... # event[:data][:submission_id]
+  #   end
+  module Webhook
+    HEADER = "X-EDF-Signature"
+    DEFAULT_TOLERANCE = 300 # seconds
+
+    # Verifies a delivery's signature and timestamp. Returns true, or raises
+    # EasyDocForms::SignatureVerificationError. +payload+ must be the raw
+    # request body string; +tolerance+ bounds |now - t| (replay window).
+    def self.verify!(payload:, header:, secret:, tolerance: DEFAULT_TOLERANCE, now: Time.now)
+      timestamp, signatures = parse_header(header)
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret, "#{timestamp}.#{payload}")
+      unless signatures.any? { |signature| secure_compare(signature, expected) }
+        raise SignatureVerificationError, "no v1 signature matches the payload"
+      end
+      if (now.to_i - timestamp).abs > tolerance
+        raise SignatureVerificationError, "timestamp outside the #{tolerance}s tolerance"
+      end
+
+      true
+    end
+
+    # Verifies a delivery, then parses and returns its envelope as a Hash with
+    # symbol keys: { event:, timestamp:, org_id:, data: }.
+    def self.construct_event(payload:, header:, secret:, tolerance: DEFAULT_TOLERANCE, now: Time.now)
+      verify!(payload: payload, header: header, secret: secret, tolerance: tolerance, now: now)
+      JSON.parse(payload, symbolize_names: true)
+    end
+
+    # Computes an X-EDF-Signature header value — for building authentic
+    # fixtures in your own tests.
+    def self.sign(payload:, secret:, timestamp: Time.now.to_i)
+      "t=#{timestamp},v1=#{OpenSSL::HMAC.hexdigest("SHA256", secret, "#{timestamp}.#{payload}")}"
+    end
+
+    # Splits "t=<unix>,v1=<hex>[,v1=<hex>...]". Unknown items are ignored for
+    # forward compatibility; multiple v1 values are all tried (secret
+    # rotation).
+    def self.parse_header(header)
+      timestamp = nil
+      signatures = []
+      header.to_s.split(",").each do |item|
+        key, _, value = item.strip.partition("=")
+        case key
+        when "t"
+          raise SignatureVerificationError, "malformed timestamp" unless value.match?(/\A\d+\z/)
+
+          timestamp = value.to_i
+        when "v1"
+          signatures << value
+        end
+      end
+      raise SignatureVerificationError, "malformed #{HEADER} header" if timestamp.nil? || signatures.empty?
+
+      [timestamp, signatures]
+    end
+    private_class_method :parse_header
+
+    def self.secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      OpenSSL.fixed_length_secure_compare(a, b)
+    end
+    private_class_method :secure_compare
+  end
+end

data/lib/easydocforms.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "easydocforms/version"
+require_relative "easydocforms/errors"
+require_relative "easydocforms/client"
+require_relative "easydocforms/webhook"
+
+# EasyDocForms turns a blank PDF intake form into a hosted, mobile-friendly
+# fillable form — and returns the completed, pixel-exact PDF plus structured
+# JSON answers.
+#
+#   client = EasyDocForms::Client.new(ENV["EASYDOCFORMS_API_KEY"])
+#   pong = client.ping
+#   # => { org_id: "...", key_name: "...", scopes: [...] }
+#
+# PHI boundary: imports are blank forms only (every import requires
+# +blank_form_attestation: true+), +external_ref+ values must never contain
+# PHI, and webhook payloads carry ids and retrieve URLs — never patient
+# answers.
+#
+# API reference: https://easydocforms.com/docs/api
+module EasyDocForms
+  DEFAULT_BASE_URL = "https://form.easydocforms.com/api/v1"
+end

data/lib/generators/easydocforms/webhook/templates/webhooks_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Receives EasyDocForms webhook deliveries. Every delivery is verified
+# against the subscription's signing secret before it is trusted.
+#
+# Webhook payloads are PHI-minimized by design: they carry ids and retrieve
+# URLs, never patient answers. Fetch answers server-side with your API key.
+class EasydocformsWebhooksController < ActionController::Base
+  skip_before_action :verify_authenticity_token
+
+  def create
+    event = EasyDocForms::Webhook.construct_event(
+      payload: request.body.read,
+      header: request.headers[EasyDocForms::Webhook::HEADER],
+      secret: Rails.application.credentials.dig(:easydocforms, :webhook_secret)
+    )
+
+    case event[:event]
+    when "import.completed"
+      # event[:data] => { import_id:, template_id:, page_count:, field_count:, review_required: }
+    when "import.failed"
+      # event[:data] => { import_id:, error: }
+    when "submission.created"
+      # event[:data] => { submission_id:, template_id:, fill_link_id:, external_ref:, retrieve_url: }
+    when "submission.pdf_ready"
+      # event[:data] => { submission_id:, template_id:, external_ref:, pdf_url: }
+    end
+
+    head :ok # respond 2xx fast; deliveries are one-shot
+  rescue EasyDocForms::SignatureVerificationError
+    head :bad_request
+  end
+end

data/lib/generators/easydocforms/webhook/webhook_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Easydocforms
+  module Generators
+    # rails generate easydocforms:webhook
+    #
+    # Creates a webhook receiver controller that verifies X-EDF-Signature and
+    # prints the route + credentials setup to finish wiring it up.
+    class WebhookGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_controller
+        copy_file "webhooks_controller.rb", "app/controllers/easydocforms_webhooks_controller.rb"
+      end
+
+      def show_instructions
+        say <<~INSTRUCTIONS
+
+          EasyDocForms webhook receiver created. Two steps to finish:
+
+          1. Add the route (config/routes.rb):
+
+               post "/webhooks/easydocforms", to: "easydocforms_webhooks#create"
+
+          2. Store the signing secret (shown once when you register the webhook):
+
+               bin/rails credentials:edit
+               # easydocforms:
+               #   webhook_secret: whsec_...
+
+             Then register the endpoint:
+
+               EasyDocForms::Client.new(ENV["EASYDOCFORMS_API_KEY"])
+                 .create_webhook(url: "https://your-app.example.com/webhooks/easydocforms")
+
+        INSTRUCTIONS
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: easydocforms
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- EasyDocForms
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: 'EasyDocForms turns a blank PDF intake form into a hosted, mobile-friendly
+  fillable form and returns the completed, pixel-exact PDF plus structured JSON answers.
+  This gem wraps the Partner API: import a blank PDF, mint a hosted patient fill link,
+  receive signed webhooks, and retrieve submissions. Zero runtime dependencies.'
+email:
+- support@easydocforms.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/easydocforms.rb
+- lib/easydocforms/client.rb
+- lib/easydocforms/errors.rb
+- lib/easydocforms/version.rb
+- lib/easydocforms/webhook.rb
+- lib/generators/easydocforms/webhook/templates/webhooks_controller.rb
+- lib/generators/easydocforms/webhook/webhook_generator.rb
+homepage: https://easydocforms.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://easydocforms.com
+  source_code_uri: https://github.com/easydocforms/easydocforms-ruby
+  documentation_uri: https://easydocforms.com/docs/api
+  changelog_uri: https://github.com/easydocforms/easydocforms-ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/easydocforms/easydocforms-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Ruby SDK for the EasyDocForms Partner API — turn blank PDF intake forms into
+  hosted fillable forms and get back completed, pixel-exact PDFs.
+test_files: []