anvil-ruby 0.1.0

data/lib/anvil/resources/webform.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Anvil
+  class Webform < Resources::Base
+    def id
+      attributes[:eid] || attributes[:id]
+    end
+
+    def eid
+      attributes[:eid]
+    end
+
+    def name
+      attributes[:name]
+    end
+
+    def slug
+      attributes[:slug]
+    end
+
+    def fields
+      Array(attributes[:fields])
+    end
+
+    # Submit data to this webform
+    #
+    # @param data [Hash] The form data to submit
+    # @return [Hash] The submission result
+    def submit(data: {})
+      result = client.graphql(self.class.send(:create_submission_mutation), variables: {
+                                forgeEid: eid,
+                                input: data
+                              })
+      raise APIError, "Failed to submit form data: #{eid}" unless result && result[:createSubmission]
+
+      result[:createSubmission]
+    end
+
+    # Get submissions for this webform
+    #
+    # @param limit [Integer] Number of submissions to return
+    # @param offset [Integer] Offset for pagination
+    # @return [Array<Hash>] The form submissions
+    def submissions(limit: 10, offset: 0)
+      result = client.graphql(self.class.send(:submissions_query), variables: {
+                                forgeEid: eid,
+                                limit: limit,
+                                offset: offset
+                              })
+
+      if result && result[:forgeSubmissions]
+        Array(result[:forgeSubmissions])
+      else
+        []
+      end
+    end
+
+    # Reload from API
+    def reload!
+      refreshed = self.class.find(eid, client: client)
+      @attributes = refreshed.attributes
+      self
+    end
+
+    class << self
+      # Create a new webform
+      #
+      # @param name [String] Name of the form
+      # @param fields [Array<Hash>] Form field definitions
+      # @param options [Hash] Additional options
+      # @return [Webform] The created webform
+      def create(name:, fields: [], **options)
+        api_key = options.delete(:api_key)
+        client = api_key ? Client.new(api_key: api_key) : self.client
+
+        payload = { name: name, fields: fields }
+        payload[:slug] = options[:slug] if options[:slug]
+
+        result = client.graphql(create_forge_mutation, variables: { input: payload })
+        raise APIError, "Failed to create webform: #{result}" unless result && result[:createForge]
+
+        new(result[:createForge], client: client)
+      end
+
+      # Find a webform by EID
+      #
+      # @param form_eid [String] The webform EID
+      # @param client [Client] Optional client instance
+      # @return [Webform] The webform
+      def find(form_eid, client: nil)
+        client ||= self.client
+
+        result = client.graphql(forge_query, variables: { eid: form_eid })
+        raise NotFoundError, "Webform not found: #{form_eid}" unless result && result[:forge]
+
+        new(result[:forge], client: client)
+      end
+
+      private
+
+      def create_forge_mutation
+        <<~GRAPHQL
+          mutation CreateForge($input: JSON) {
+            createForge(variables: $input) {
+              eid
+              name
+              slug
+              fields
+              createdAt
+            }
+          }
+        GRAPHQL
+      end
+
+      def forge_query
+        <<~GRAPHQL
+          query GetForge($eid: String!) {
+            forge(eid: $eid) {
+              eid
+              name
+              slug
+              fields
+              createdAt
+            }
+          }
+        GRAPHQL
+      end
+
+      def create_submission_mutation
+        <<~GRAPHQL
+          mutation CreateSubmission($forgeEid: String!, $input: JSON) {
+            createSubmission(forgeEid: $forgeEid, variables: $input) {
+              eid
+              data
+              createdAt
+            }
+          }
+        GRAPHQL
+      end
+
+      def submissions_query
+        <<~GRAPHQL
+          query GetForgeSubmissions($forgeEid: String!, $limit: Int, $offset: Int) {
+            forgeSubmissions(forgeEid: $forgeEid, limit: $limit, offset: $offset) {
+              eid
+              data
+              createdAt
+            }
+          }
+        GRAPHQL
+      end
+    end
+  end
+end

data/lib/anvil/resources/webhook.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Anvil
+  class Webhook < Resources::Base
+    # Webhook actions/events
+    ACTIONS = %w[
+      weldCreate
+      forgeComplete
+      weldComplete
+      signerComplete
+      signerUpdateStatus
+      etchPacketComplete
+      documentGroupCreate
+      webhookTest
+    ].freeze
+
+    attr_reader :raw_payload, :token
+
+    def initialize(payload:, token: nil, **options)
+      @raw_payload = payload.is_a?(String) ? payload : payload.to_json
+      @token = token
+
+      begin
+        parsed = JSON.parse(@raw_payload, symbolize_names: true)
+        super(parsed, **options)
+      rescue JSON::ParserError => e
+        raise WebhookError, "Invalid webhook payload: #{e.message}"
+      end
+    end
+
+    def action
+      attributes[:action]
+    end
+
+    def data
+      attributes[:data]
+    end
+
+    def timestamp
+      attributes[:timestamp] || attributes[:created_at]
+    end
+
+    # Verify the webhook token
+    def valid?(expected_token = nil)
+      expected_token ||= Anvil.configuration.webhook_token
+
+      raise WebhookVerificationError, 'No webhook token configured' if expected_token.nil? || expected_token.empty?
+
+      return false unless token
+
+      # Constant-time comparison to prevent timing attacks
+      secure_compare(token, expected_token)
+    end
+
+    def valid!
+      raise WebhookVerificationError, 'Invalid webhook token' unless valid?
+
+      true
+    end
+
+    # Check if data is encrypted
+    def encrypted?
+      data.is_a?(String) && data.match?(%r{^[A-Za-z0-9+/=]+$})
+    end
+
+    # Decrypt the webhook data (requires RSA private key)
+    def decrypt(private_key_path = nil)
+      return data unless encrypted?
+
+      private_key_path ||= ENV.fetch('ANVIL_RSA_PRIVATE_KEY_PATH', nil)
+
+      unless private_key_path && File.exist?(private_key_path)
+        raise WebhookError, 'Private key not found for decrypting webhook data'
+      end
+
+      begin
+        private_key = OpenSSL::PKey::RSA.new(File.read(private_key_path))
+        encrypted_data = Base64.decode64(data)
+        decrypted = private_key.private_decrypt(encrypted_data, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
+        JSON.parse(decrypted, symbolize_names: true)
+      rescue StandardError => e
+        raise WebhookError, "Failed to decrypt webhook data: #{e.message}"
+      end
+    end
+
+    # Helper methods for specific webhook types
+    def workflow_created?
+      action == 'weldCreate'
+    end
+
+    def webform_complete?
+      action == 'forgeComplete'
+    end
+
+    def workflow_complete?
+      action == 'weldComplete'
+    end
+
+    def signer_complete?
+      action == 'signerComplete'
+    end
+
+    def signer_status_updated?
+      action == 'signerUpdateStatus'
+    end
+
+    def signature_packet_complete?
+      action == 'etchPacketComplete'
+    end
+
+    def document_group_created?
+      action == 'documentGroupCreate'
+    end
+
+    def test?
+      action == 'webhookTest'
+    end
+
+    # Extract specific data based on webhook type
+    def signer_eid
+      data[:signerEid] if signer_complete? || signer_status_updated?
+    end
+
+    def packet_eid
+      data[:packetEid] if signature_packet_complete? || signer_complete?
+    end
+
+    def workflow_eid
+      data[:weldEid] || data[:eid] if workflow_created? || workflow_complete?
+    end
+
+    def webform_eid
+      data[:forgeEid] if webform_complete?
+    end
+
+    def signer_status
+      data[:status] if signer_status_updated?
+    end
+
+    def signer_name
+      data[:signerName] if signer_complete? || signer_status_updated?
+    end
+
+    def signer_email
+      data[:signerEmail] if signer_complete? || signer_status_updated?
+    end
+
+    class << self
+      # Verify and parse a webhook request
+      #
+      # @param request [ActionDispatch::Request, Rack::Request] The incoming request
+      # @return [Webhook] The parsed and verified webhook
+      def from_request(request)
+        payload = request.body.read
+        token = extract_token(request)
+
+        webhook = new(payload: payload, token: token)
+        webhook.valid!
+        webhook
+      end
+
+      # Create a test webhook for development
+      def create_test(action: 'webhookTest', data: {})
+        payload = {
+          action: action,
+          data: data,
+          timestamp: Time.now.iso8601
+        }
+
+        new(
+          payload: payload.to_json,
+          token: Anvil.configuration.webhook_token
+        )
+      end
+
+      private
+
+      def extract_token(request)
+        # Token can be in header or params
+        request.headers['X-Anvil-Token'] ||
+          request.params['token'] ||
+          request.params['anvil_token']
+      end
+    end
+
+    private
+
+    def secure_compare(str1, str2)
+      return false unless str1.bytesize == str2.bytesize
+
+      l = str1.unpack('C*')
+      r = str2.unpack('C*')
+      result = 0
+
+      l.zip(r).each { |x, y| result |= x ^ y }
+      result.zero?
+    end
+  end
+end

data/lib/anvil/resources/workflow.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Anvil
+  class Workflow < Resources::Base
+    def id
+      attributes[:eid] || attributes[:id]
+    end
+
+    def eid
+      attributes[:eid]
+    end
+
+    def name
+      attributes[:name]
+    end
+
+    def status
+      attributes[:status]
+    end
+
+    def slug
+      attributes[:slug]
+    end
+
+    def published?
+      status == 'published'
+    end
+
+    def draft?
+      status == 'draft'
+    end
+
+    # Start the workflow with initial data
+    #
+    # @param data [Hash] The data to start the workflow with
+    # @return [Hash] The submission data
+    def start(data: {})
+      result = client.graphql(self.class.send(:create_weld_data_mutation), variables: {
+                                eid: eid,
+                                input: data
+                              })
+      raise APIError, "Failed to start workflow: #{eid}" unless result && result[:createWeldData]
+
+      result[:createWeldData]
+    end
+
+    # Get submissions for this workflow
+    #
+    # @param limit [Integer] Number of submissions to return
+    # @param offset [Integer] Offset for pagination
+    # @return [Array<Hash>] The workflow submissions
+    def submissions(limit: 10, offset: 0)
+      result = client.graphql(self.class.send(:weld_data_query), variables: {
+                                eid: eid,
+                                limit: limit,
+                                offset: offset
+                              })
+
+      if result && result[:weldData]
+        Array(result[:weldData])
+      else
+        []
+      end
+    end
+
+    # Reload from API
+    def reload!
+      refreshed = self.class.find(eid, client: client)
+      @attributes = refreshed.attributes
+      self
+    end
+
+    class << self
+      # Create a new workflow
+      #
+      # @param name [String] Name of the workflow
+      # @param options [Hash] Additional options (forges, casts, slug)
+      # @return [Workflow] The created workflow
+      def create(name:, **options)
+        api_key = options.delete(:api_key)
+        client = api_key ? Client.new(api_key: api_key) : self.client
+
+        payload = { name: name }
+        payload[:slug] = options[:slug] if options[:slug]
+        payload[:forges] = options[:forges] if options[:forges]
+        payload[:casts] = options[:casts] if options[:casts]
+
+        result = client.graphql(create_weld_mutation, variables: { input: payload })
+        raise APIError, "Failed to create workflow: #{result}" unless result && result[:createWeld]
+
+        new(result[:createWeld], client: client)
+      end
+
+      # Find a workflow by EID
+      #
+      # @param workflow_eid [String] The workflow EID
+      # @param client [Client] Optional client instance
+      # @return [Workflow] The workflow
+      def find(workflow_eid, client: nil)
+        client ||= self.client
+
+        result = client.graphql(weld_query, variables: { eid: workflow_eid })
+        raise NotFoundError, "Workflow not found: #{workflow_eid}" unless result && result[:weld]
+
+        new(result[:weld], client: client)
+      end
+
+      private
+
+      def create_weld_mutation
+        <<~GRAPHQL
+          mutation CreateWeld($input: JSON) {
+            createWeld(variables: $input) {
+              eid
+              name
+              slug
+              status
+              createdAt
+            }
+          }
+        GRAPHQL
+      end
+
+      def weld_query
+        <<~GRAPHQL
+          query GetWeld($eid: String!) {
+            weld(eid: $eid) {
+              eid
+              name
+              slug
+              status
+              createdAt
+              forges {
+                eid
+                name
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def create_weld_data_mutation
+        <<~GRAPHQL
+          mutation CreateWeldData($eid: String!, $input: JSON) {
+            createWeldData(weldEid: $eid, variables: $input) {
+              eid
+              status
+              createdAt
+              data
+            }
+          }
+        GRAPHQL
+      end
+
+      def weld_data_query
+        <<~GRAPHQL
+          query GetWeldData($eid: String!, $limit: Int, $offset: Int) {
+            weldData(weldEid: $eid, limit: $limit, offset: $offset) {
+              eid
+              status
+              createdAt
+              data
+            }
+          }
+        GRAPHQL
+      end
+    end
+  end
+end

data/lib/anvil/response.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Anvil
+  class Response
+    attr_reader :http_response, :raw_body, :code, :headers
+
+    def initialize(http_response)
+      @http_response = http_response
+      @code = http_response.code.to_i
+      @raw_body = http_response.body
+      @headers = extract_headers(http_response)
+    end
+
+    def success?
+      code >= 200 && code < 300
+    end
+
+    def error?
+      !success?
+    end
+
+    def body
+      return raw_body if binary?
+
+      @body ||= begin
+        JSON.parse(raw_body, symbolize_names: true)
+      rescue JSON::ParserError
+        raw_body
+      end
+    end
+
+    def data
+      return raw_body if binary?
+
+      if body.is_a?(Hash)
+        body[:data] || body
+      else
+        body
+      end
+    end
+
+    def errors
+      return [] unless error? && body.is_a?(Hash)
+
+      body[:errors] || body[:fields] || []
+    end
+
+    def error_message
+      return nil unless error?
+
+      if errors.any?
+        errors.map { |e| e[:message] || e['message'] }.join(', ')
+      elsif body.is_a?(Hash) && body[:message]
+        body[:message]
+      else
+        "HTTP #{code} Error"
+      end
+    end
+
+    # Rate limiting headers
+    def rate_limit
+      headers['x-ratelimit-limit']&.to_i
+    end
+
+    def rate_limit_remaining
+      headers['x-ratelimit-remaining']&.to_i
+    end
+
+    def rate_limit_reset
+      reset = headers['x-ratelimit-reset']&.to_i
+      Time.at(reset) if reset
+    end
+
+    def retry_after
+      headers['retry-after']&.to_i
+    end
+
+    def content_type
+      headers['content-type'] || ''
+    end
+
+    def binary?
+      content_type.include?('application/pdf') ||
+        content_type.include?('application/octet-stream') ||
+        content_type.include?('application/zip')
+    end
+
+    private
+
+    def extract_headers(response)
+      headers = {}
+      response.each_header do |key, value|
+        headers[key.downcase] = value
+      end
+      headers
+    end
+  end
+end

data/lib/anvil/version.rb

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

data/lib/anvil.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'base64'
+require 'uri'
+require 'date'
+
+require_relative 'anvil/version'
+require_relative 'anvil/configuration'
+require_relative 'anvil/errors'
+require_relative 'anvil/response'
+require_relative 'anvil/client'
+require_relative 'anvil/rate_limiter'
+require_relative 'anvil/resources/base'
+require_relative 'anvil/resources/pdf'
+require_relative 'anvil/resources/signature'
+require_relative 'anvil/resources/webhook'
+require_relative 'anvil/resources/workflow'
+require_relative 'anvil/resources/webform'
+
+module Anvil
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    def reset_configuration!
+      self.configuration = Configuration.new
+      @default_client = nil
+    end
+
+    # Convenience methods for quick configuration
+    def api_key=(key)
+      configure { |config| config.api_key = key }
+    end
+
+    def api_key
+      configuration&.api_key || ENV.fetch('ANVIL_API_KEY', nil)
+    end
+
+    def environment=(env)
+      configure { |config| config.environment = env }
+    end
+
+    def environment
+      configuration&.environment || :production
+    end
+
+    def development?
+      environment == :development
+    end
+
+    def production?
+      environment == :production
+    end
+
+    # Execute a GraphQL query
+    #
+    # @param query [String] The GraphQL query string
+    # @param variables [Hash] Variables to pass to the query
+    # @return [Hash] The query result data
+    def query(query:, variables: {})
+      default_client.query(query: query, variables: variables)
+    end
+
+    # Execute a GraphQL mutation
+    #
+    # @param mutation [String] The GraphQL mutation string
+    # @param variables [Hash] Variables to pass to the mutation
+    # @return [Hash] The mutation result data
+    def mutation(mutation:, variables: {})
+      default_client.mutation(mutation: mutation, variables: variables)
+    end
+
+    private
+
+    def default_client
+      @default_client ||= Client.new
+    end
+  end
+end
+
+# Initialize with default configuration
+Anvil.reset_configuration!