autentique 0.1.0

data/lib/autentique/models/document_input.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Models
+    class DocumentInput
+      attr_accessor :name, :message, :reminder, :sortable, :footer, :refusable,
+                    :qualified, :scrolling_required, :stop_on_rejected,
+                    :new_signature_style, :show_audit_page, :ignore_cpf,
+                    :ignore_birthdate, :email_template_id, :deadline_at,
+                    :cc, :expiration, :configs, :locale
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      def to_h
+        {
+          name: name,
+          message: message,
+          reminder: reminder,
+          sortable: sortable,
+          footer: footer,
+          refusable: refusable,
+          qualified: qualified,
+          scrolling_required: scrolling_required,
+          stop_on_rejected: stop_on_rejected,
+          new_signature_style: new_signature_style,
+          show_audit_page: show_audit_page,
+          ignore_cpf: ignore_cpf,
+          ignore_birthdate: ignore_birthdate,
+          email_template_id: email_template_id,
+          deadline_at: deadline_at,
+          cc: cc,
+          expiration: expiration,
+          configs: configs,
+          locale: locale
+        }.compact
+      end
+    end
+  end
+end

data/lib/autentique/models/signature.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Models
+    class Signature
+      attr_reader :public_id, :name, :email, :created_at, :action, :link,
+                  :user, :viewed, :signed, :rejected, :email_events, :delivery_method
+
+      def initialize(attributes = {})
+        @public_id = attributes['public_id']
+        @name = attributes['name']
+        @email = attributes['email']
+        @created_at = attributes['created_at']
+        @action = attributes['action']
+        @link = attributes['link']
+        @user = attributes['user']
+        @viewed = attributes['viewed']
+        @signed = attributes['signed']
+        @rejected = attributes['rejected']
+        @email_events = attributes['email_events']
+        @delivery_method = attributes['delivery_method']
+      end
+
+      def signed?
+        !@signed.nil?
+      end
+
+      def rejected?
+        !@rejected.nil?
+      end
+
+      def pending?
+        @signed.nil? && @rejected.nil?
+      end
+
+      def short_link
+        @link&.dig('short_link')
+      end
+    end
+  end
+end

data/lib/autentique/models/signer_input.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Models
+    class SignerInput
+      attr_accessor :email, :phone, :name, :action, :delivery_method,
+                    :configs, :security_verifications, :positions
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      def to_h
+        {
+          email: email,
+          phone: phone,
+          name: name,
+          action: action,
+          delivery_method: delivery_method,
+          configs: configs,
+          security_verifications: security_verifications,
+          positions: positions
+        }.compact
+      end
+    end
+  end
+end

data/lib/autentique/resources/documents/create.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Resources
+    class Documents
+      module Create
+        def create(file:, document:, signers:, organization_id: nil, folder_id: nil, sandbox: nil) # rubocop:disable Metrics/ParameterLists
+          doc_input = document.is_a?(Models::DocumentInput) ? document : Models::DocumentInput.new(document)
+          signer_inputs = signers.map { |s| s.is_a?(Models::SignerInput) ? s : Models::SignerInput.new(s) }
+
+          use_sandbox = sandbox.nil? ? client.sandbox : sandbox
+          if use_sandbox
+            doc_hash = doc_input.to_h.merge(sandbox: true)
+            doc_input = Models::DocumentInput.new(doc_hash)
+          end
+
+          response = upload_document(
+            file: file,
+            document: doc_input,
+            signers: signer_inputs,
+            organization_id: organization_id,
+            folder_id: folder_id
+          )
+
+          document_data = response.dig('data', 'createDocument')
+          raise QueryError.new('Failed to create document', response['errors']) if document_data.nil?
+
+          Models::Document.new(document_data)
+        end
+      end
+    end
+  end
+end

data/lib/autentique/resources/documents/delete.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Resources
+    class Documents
+      module Delete
+        # Delete a document
+        #
+        # @param id [String] The document ID (UUID)
+        # @return [Boolean]
+        def delete(id)
+          query = client.graphql_client.parse <<-GRAPHQL
+            mutation($id: UUID!) {
+              deleteDocument(id: $id)
+            }
+          GRAPHQL
+
+          result = client.query(query, variables: { id: id })
+          raise QueryError.new('Query failed', result.errors.messages) if result.errors.any?
+
+          result.data.delete_document
+        end
+      end
+    end
+  end
+end

data/lib/autentique/resources/documents/find.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Resources
+    class Documents
+      module Find
+        def find(id) # rubocop:disable Metrics/MethodLength
+          query = client.graphql_client.parse <<-GRAPHQL
+          query($id: UUID!) {
+            document(id: $id) {
+              id
+              name
+              refusable
+              sortable
+              created_at
+              files { original signed }
+              signatures {
+                public_id
+                name
+                email
+                created_at
+                action { name }
+                link { short_link }
+                user { id name email }
+                viewed { created_at }
+                signed { created_at }
+                rejected { created_at reason }
+                email_events { sent opened delivered refused reason }
+              }
+            }
+          }
+          GRAPHQL
+
+          result = client.query(query, variables: { id: id })
+          raise QueryError.new('Query failed', result.errors.messages) if result.errors.any?
+
+          document_data = result.data.document
+          raise NotFoundError, "Document with ID #{id} not found" if document_data.nil?
+
+          Models::Document.new(document_data.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/autentique/resources/documents/list.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Resources
+    class Documents
+      module List
+        def list(status: nil, limit: 60, page: 1) # rubocop:disable Metrics/MethodLength
+          query_string = if status
+                           <<-GRAPHQL
+          query($status: DocumentStatusEnum, $limit: Int!, $page: Int!) {
+            documents(status: $status, limit: $limit, page: $page) {
+              total
+              data { id name created_at signatures { public_id name email } }
+            }
+          }
+                           GRAPHQL
+                         else
+                           <<-GRAPHQL
+          query($limit: Int, $page: Int) {
+            documents(limit: $limit, page: $page) {
+              total
+              data { id name created_at signatures { public_id name email } }
+            }
+          }
+                           GRAPHQL
+                         end
+
+          query = client.graphql_client.parse(query_string)
+          variables = { limit: limit, page: page }
+          variables[:status] = status if status
+
+          result = client.query(query, variables: variables)
+          raise QueryError.new('Query failed', result.errors.messages) if result.errors.any?
+
+          docs = result.data.documents&.data || []
+          docs.map { |doc| Models::Document.new(doc.to_h) }
+        end
+      end
+    end
+  end
+end

data/lib/autentique/resources/documents/pending.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Resources
+    class Documents
+      module Pending
+        def self.pending_query(client)
+          client.graphql_client.parse <<~GRAPHQL
+            query($limit: Int!, $page: Int!) {
+              documents(status: PENDING, limit: $limit, page: $page) {
+                total
+                data {
+                  id
+                  name
+                  created_at
+                  signatures {
+                    public_id
+                    name
+                    email
+                    user { id name email phone }
+                    delivery_method
+                    email_events { sent opened delivered refused reason }
+                  }
+                }
+              }
+            }
+          GRAPHQL
+        end
+
+        def pending(limit: 60, page: 1)
+          query = Pending.pending_query(client)
+          result = client.query(query, variables: { limit: limit, page: page })
+          raise QueryError.new('Query failed', result.errors.messages) if result.errors.any?
+
+          result.data.documents&.data&.map { |doc| Models::Document.new(doc.to_h) } || []
+        end
+      end
+    end
+  end
+end

data/lib/autentique/resources/documents.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'mime/types'
+
+require_relative 'documents/create'
+require_relative 'documents/find'
+require_relative 'documents/pending'
+require_relative 'documents/list'
+require_relative 'documents/delete'
+
+module Autentique
+  module Resources
+    class Documents
+      include Documents::Create
+      include Documents::Find
+      include Documents::Pending
+      include Documents::List
+      include Documents::Delete
+
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      # Upload document using multipart/form-data
+      def upload_document(file:, document:, signers:, organization_id: nil, folder_id: nil)
+        uri = URI(Client::API_ENDPOINT)
+
+        # Build GraphQL mutation
+        mutation = build_create_mutation(organization_id, folder_id)
+
+        # Build variables
+        variables = {
+          document: document.to_h,
+          signers: signers.map(&:to_h),
+          file: nil
+        }
+
+        # Prepare multipart request
+        boundary = "----RubyAutentiqueGem#{Time.now.to_i}"
+        body = build_multipart_body(
+          mutation: mutation,
+          variables: variables,
+          file: file,
+          boundary: boundary
+        )
+
+        # Make request
+        http = build_http_client(uri)
+        request = Net::HTTP::Post.new(uri.path)
+        request['Authorization'] = "Bearer #{client.api_key}"
+        request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+        request.body = body
+
+        response = http.request(request)
+
+        raise UploadError, "Upload failed: #{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body)
+      end
+
+      # Build the GraphQL mutation string for document creation
+      def build_create_mutation(organization_id, folder_id) # rubocop:disable Metrics/MethodLength
+        mutation = <<-GRAPHQL
+          mutation CreateDocumentMutation(
+            $document: DocumentInput!,
+            $signers: [SignerInput!]!,
+            $file: Upload!
+          ) {
+            createDocument(
+              document: $document,
+              signers: $signers,
+              file: $file
+        GRAPHQL
+
+        mutation += ",\n      organization_id: #{organization_id}" if organization_id
+        mutation += ",\n      folder_id: \"#{folder_id}\"" if folder_id
+
+        mutation += <<-GRAPHQL
+            ) {
+              id
+              name
+              refusable
+              sortable
+              created_at
+              signatures {
+                public_id
+                name
+                email
+                created_at
+                action { name }
+                link { short_link }
+                user { id name email }
+              }
+            }
+          }
+        GRAPHQL
+
+        mutation
+      end
+
+      # Build multipart/form-data body for file uploads
+      def build_multipart_body(mutation:, variables:, file:, boundary:)
+        parts = []
+        parts.concat(build_operations_part(mutation, variables, boundary))
+        parts.concat(build_map_part(boundary))
+        parts.concat(build_file_part(file, boundary))
+        parts << "--#{boundary}--\r\n"
+        parts.join
+      end
+
+      def build_operations_part(mutation, variables, boundary)
+        operations = { query: mutation, variables: variables }
+        [
+          "--#{boundary}\r\n",
+          "Content-Disposition: form-data; name=\"operations\"\r\n\r\n",
+          "#{operations.to_json}\r\n"
+        ]
+      end
+
+      def build_map_part(boundary)
+        map = { file: ['variables.file'] }
+        [
+          "--#{boundary}\r\n",
+          "Content-Disposition: form-data; name=\"map\"\r\n\r\n",
+          "#{map.to_json}\r\n"
+        ]
+      end
+
+      def build_file_part(file, boundary)
+        content, name, type = extract_file_info(file)
+        [
+          "--#{boundary}\r\n",
+          "Content-Disposition: form-data; name=\"file\"; filename=\"#{name}\"\r\n",
+          "Content-Type: #{type}\r\n\r\n",
+          content,
+          "\r\n"
+        ]
+      end
+
+      def extract_file_info(file)
+        if file.is_a?(String)
+          [File.binread(file), File.basename(file),
+           MIME::Types.type_for(file).first&.content_type || 'application/pdf']
+        elsif file.is_a?(Hash)
+          [file[:io].read, file[:name] || 'document.pdf', file[:mime_type] || 'application/pdf']
+        else
+          [file.read, 'document.pdf', 'application/pdf']
+        end
+      end
+
+      def build_http_client(uri)
+        Net::HTTP.new(uri.host, uri.port).tap do |http|
+          http.use_ssl = true
+        end
+      end
+    end
+  end
+end

data/lib/autentique/resources/folders.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Resources
+    class Folders
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # List all folders
+      #
+      # @return [Array<Hash>]
+      def list(limit: 30, page: 1)
+        query = client.graphql_client.parse <<-GRAPHQL
+          query($limit: Int!, $page: Int!) {
+            folders(limit: $limit, page: $page) {
+              total
+              data {
+                id
+                name
+                created_at
+              }
+            }
+          }
+        GRAPHQL
+
+        result = client.query(query, variables: { limit: limit, page: page })
+        raise QueryError.new('Query failed', result.errors.messages) if result.errors.any?
+
+        result.data.folders.data.map(&:to_h)
+      end
+
+      # Create a new folder
+      #
+      # @param name [String] The folder name
+      # @param parent_id [String, nil] The parent folder ID
+      # @return [Hash]
+      def create(name:, parent_id: nil)
+        query = client.graphql_client.parse <<-GRAPHQL
+          mutation($folder: FolderInput!, $parent_id: UUID) {
+            createFolder(folder: $folder, parent_id: $parent_id) {
+              id
+              name
+              created_at
+            }
+          }
+        GRAPHQL
+
+        variables = { folder: { name: name } }
+        variables[:parent_id] = parent_id if parent_id
+
+        result = client.query(query, variables: variables)
+        raise QueryError.new('Query failed', result.errors.messages) if result.errors.any?
+
+        result.data.create_folder.to_h
+      end
+
+      # Delete a folder
+      #
+      # @param id [String] The folder ID
+      # @return [Boolean]
+      def delete(id:)
+        query = client.graphql_client.parse <<-GRAPHQL
+          mutation($id: UUID!) {
+            deleteFolder(id: $id)
+          }
+        GRAPHQL
+
+        result = client.query(query, variables: { id: id })
+        raise QueryError.new('Query failed', result.errors.messages) if result.errors.any?
+
+        result.data.delete_folder
+      end
+    end
+  end
+end

data/lib/autentique/resources.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Autentique
+  module Resources
+  end
+end

data/lib/autentique/version.rb

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

data/lib/autentique.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'autentique/version'
+require_relative 'autentique/errors'
+require_relative 'autentique/client'
+require_relative 'autentique/models/document'
+require_relative 'autentique/resources'
+require_relative 'autentique/resources/documents'
+require_relative 'autentique/resources/folders'
+
+# Main module for the Autentique gem
+#
+# @example Basic usage
+#   client = Autentique::Client.new(api_key: 'your_api_key')
+#
+#   # Create a document
+#   document = client.documents.create(
+#     file: '/path/to/contract.pdf',
+#     document: { name: 'Contract' },
+#     signers: [
+#       { email: 'signer@example.com', action: 'SIGN' }
+#     ]
+#   )
+#
+#   # Retrieve a document
+#   doc = client.documents.find('document-uuid')
+#
+#   # List pending documents
+#   pending_docs = client.documents.pending
+#
+module Autentique
+  class << self
+    # Configure the Autentique client with default settings
+    #
+    # @yield [Configuration] configuration object
+    # @return [Configuration]
+    def configure
+      yield configuration
+    end
+
+    # Get the current configuration
+    #
+    # @return [Configuration]
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Create a new client with default configuration
+    #
+    # @return [Client]
+    def client
+      @client ||= Client.new(
+        api_key: configuration.api_key,
+        sandbox: configuration.sandbox
+      )
+    end
+
+    # Reset the configuration
+    def reset
+      @configuration = Configuration.new
+      @client = nil
+    end
+  end
+
+  # Configuration class for global settings
+  class Configuration
+    attr_accessor :api_key, :sandbox
+
+    def initialize
+      @api_key = ENV.fetch('AUTENTIQUE_API_KEY', nil)
+      @sandbox = false
+    end
+  end
+end