collavre_linear 0.1.0

data/app/observers/collavre_linear/comment_sync_observer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module CollavreLinear
+  # Auto-triggers an outbound Linear comment sync when a human posts a chat
+  # message in the Main topic of a creative that is linked to a Linear issue.
+  #
+  # Mixed into Collavre::Comment via the engine's `to_prepare` block:
+  #
+  #   Collavre::Comment.include CollavreLinear::CommentSyncObserver
+  #
+  # Mirrors CreativeSyncObserver: the transient `skip_linear_sync` flag lets the
+  # inbound applier suppress the echo when it mirrors a Linear comment locally
+  # (otherwise the mirrored comment would bounce straight back out to Linear).
+  module CommentSyncObserver
+    extend ActiveSupport::Concern
+
+    included do
+      # Transient, per-record suppression flag set by the inbound applier on the
+      # comment it mirrors from Linear so this after_commit does not echo it back.
+      attr_accessor :skip_linear_sync
+
+      after_create_commit  :enqueue_linear_comment_sync
+      after_update_commit  :enqueue_linear_comment_update
+      after_destroy_commit :enqueue_linear_comment_delete
+    end
+
+    private
+
+    def enqueue_linear_comment_sync
+      return unless linear_syncable_comment?
+
+      CollavreLinear::OutboundCommentSyncJob.perform_later(id)
+    rescue StandardError => e
+      log_enqueue_failure("sync", e)
+    end
+
+    # Propagate a local edit to Linear. A single core update can change content,
+    # `private`, and `topic_id` together, so re-check syncability: if the comment
+    # turned private or moved out of Main, remove its Linear mirror rather than
+    # pushing the now-hidden body outward. `skip_linear_sync` suppresses the echo
+    # when the inbound applier rewrites content from Linear.
+    def enqueue_linear_comment_update
+      return if skip_linear_sync
+
+      comment_link = CollavreLinear::CommentLink.find_by(comment_id: id)
+
+      unless comment_link
+        # No mirror: either never synced, or a prior update tore it down when the
+        # comment went private / left Main. If it is syncable again, recreate the
+        # mirror so re-entering visibility doesn't leave it permanently off Linear.
+        # The sync job locks the IssueLink and re-checks CommentLink existence, so
+        # this can't duplicate a mirror the create path is still building.
+        CollavreLinear::OutboundCommentSyncJob.perform_later(id) if linear_syncable_comment?
+        return
+      end
+
+      unless linear_syncable_comment?
+        CollavreLinear::OutboundCommentDeleteJob.perform_later(comment_link.id)
+        return
+      end
+
+      return unless saved_change_to_content?
+
+      CollavreLinear::OutboundCommentUpdateJob.perform_later(id)
+    rescue StandardError => e
+      log_enqueue_failure("update", e)
+    end
+
+    # Propagate a local deletion to Linear. The comment row is gone by the time
+    # this after-commit runs, so the CommentLink (not cascade-deleted — no FK on
+    # comment_id) is the only handle on the Linear comment id; the job consumes it.
+    def enqueue_linear_comment_delete
+      return if skip_linear_sync
+
+      comment_link = CollavreLinear::CommentLink.find_by(comment_id: id)
+      return unless comment_link
+
+      CollavreLinear::OutboundCommentDeleteJob.perform_later(comment_link.id)
+    rescue StandardError => e
+      log_enqueue_failure("delete", e)
+    end
+
+    def log_enqueue_failure(kind, error)
+      # Never let sync scheduling break the host transaction's commit callbacks.
+      Rails.logger.error(
+        "[CollavreLinear::CommentSyncObserver] failed to enqueue comment #{kind} for " \
+        "comment #{id}: #{error.class}: #{error.message}"
+      )
+    end
+
+    # Delegates to the shared predicate so the observer and the outbound update
+    # job (which re-checks at run time) can never diverge on what is syncable.
+    def linear_syncable_comment?
+      CollavreLinear::CommentSyncability.syncable?(self)
+    end
+  end
+end

data/app/observers/collavre_linear/creative_sync_observer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module CollavreLinear
+  # Auto-triggers an outbound Linear sync whenever a Collavre::Creative inside a
+  # linked subtree is created, updated, moved, or destroyed.
+  #
+  # Mixed into Collavre::Creative via the engine's `to_prepare` block:
+  #
+  #   Collavre::Creative.include CollavreLinear::CreativeSyncObserver
+  #
+  # which registers `after_commit` and adds the transient `skip_linear_sync`
+  # accessor.
+  #
+  # Loop guard: the inbound applier (Task 10) sets `creative.skip_linear_sync =
+  # true` on records it mutates so the resulting after_commit does NOT bounce a
+  # change back to Linear. The flag is a per-record transient attribute (not
+  # persisted), so it only suppresses the single in-memory instance that applied
+  # the inbound change.
+  module CreativeSyncObserver
+    extend ActiveSupport::Concern
+
+    included do
+      # Transient, per-record suppression flag used by the inbound applier.
+      attr_accessor :skip_linear_sync
+
+      # Transient storage for archive data captured before the row is gone.
+      attr_accessor :_linear_archive_issue_id, :_linear_archive_account_id
+
+      # Transient flag: did the just-committed save touch a Linear-relevant
+      # column? Captured in after_save (where saved_changes is reliable) so the
+      # after_commit hook can short-circuit WITHOUT a DB query. saved_changes is
+      # cleared by the time after_commit runs (esp. under transactional tests),
+      # so it cannot be read there directly.
+      attr_accessor :_linear_relevant_change
+
+      # Transient flag: did this save re-parent the creative (parent_id change)?
+      # A move carries its whole subtree, but the core move hook touches
+      # descendants via `update_all` (no callbacks fire on them), so their sync
+      # must be fanned out from the moved root. Same capture-in-after_save reason
+      # as above.
+      attr_accessor :_linear_parent_changed
+
+      # prepend: true ensures we run before the dependent: :destroy cascade that
+      # deletes IssueLinks — which is added by a separate engine initializer.
+      before_destroy :capture_linear_archive_info, prepend: true
+      after_save :capture_linear_relevant_change
+      after_commit :enqueue_linear_outbound_sync
+    end
+
+    private
+
+    # Capture linear_issue_id and account_id before the creative (and its
+    # dependent IssueLink) are deleted from the DB.  Stored in transient attrs
+    # so the after_commit destroy branch can read them without hitting a gone row.
+    def capture_linear_archive_info
+      issue_link = linear_issue_links.first
+      return unless issue_link
+
+      self._linear_archive_issue_id  = issue_link.linear_issue_id
+      self._linear_archive_account_id = issue_link.project_link.account_id
+    rescue StandardError => e
+      Rails.logger.error(
+        "[CollavreLinear::CreativeSyncObserver] before_destroy capture failed for " \
+        "creative #{id}: #{e.class}: #{e.message}"
+      )
+    end
+
+    # Columns whose change can alter the exported Linear issue (mirrors what
+    # CreativeExporter hashes: description -> title/description, sequence ->
+    # priority, data -> state/labels) plus parent_id (re-parenting -> parentId).
+    LINEAR_RELEVANT_COLUMNS = %w[description sequence data parent_id].freeze
+
+    # Record — in after_save, where saved_changes is reliable — whether this
+    # save touched a Linear-relevant column. A create always counts (its seeded
+    # attributes populate the whole row).
+    def capture_linear_relevant_change
+      self._linear_relevant_change =
+        if previously_new_record?
+          true
+        else
+          (saved_changes.keys & LINEAR_RELEVANT_COLUMNS).any?
+        end
+      self._linear_parent_changed = saved_change_to_parent_id?
+    end
+
+    def enqueue_linear_outbound_sync
+      return if skip_linear_sync
+
+      # Destroys are driven ENTIRELY by what before_destroy captured. By the time
+      # this after_commit runs, the ProjectLink/IssueLink rows are already gone
+      # via dependent: :destroy, so `linked_subtree?` is unreliable here — it
+      # returns false for the link OWNER itself, which would otherwise swallow
+      # the captured archive id and leak a live Linear issue. Trust the captured
+      # ids; enqueue_archive_if_captured no-ops when nothing was captured (an
+      # unlinked creative), so this is safe for every destroy.
+      if destroyed?
+        enqueue_archive_if_captured
+        return
+      end
+
+      # Cheap in-memory short-circuit BEFORE any DB work: `after_commit` fires for
+      # every Creative write app-wide. An update/create with no Linear-relevant
+      # column change can't affect the exported issue, so skip the subtree query.
+      return if relevant_change_absent?
+      return unless linked_subtree?
+
+      mark_issue_link_dirty
+
+      # A re-parent moves this creative's whole subtree into the linked root, but
+      # the core move hook only `update_all`-touches descendants (no callbacks),
+      # so they never enqueue themselves. Fan out to each so pre-existing children
+      # reach Linear too. Per-creative jobs self-order via the exporter's
+      # ParentNotExportedError retry, so enqueue order doesn't matter. Non-move
+      # changes (description/data/sequence) only affect this one creative.
+      target_ids = _linear_parent_changed ? self_and_descendants.ids : [ id ]
+      target_ids.each { |cid| CollavreLinear::OutboundSyncJob.perform_later(cid) }
+    rescue StandardError => e
+      # Never let a sync-scheduling failure break the host transaction's
+      # commit callbacks.
+      Rails.logger.error(
+        "[CollavreLinear::CreativeSyncObserver] failed to enqueue sync for " \
+        "creative #{id}: #{e.class}: #{e.message}"
+      )
+    end
+
+    # True when this commit touched no Linear-relevant column. Only reached for
+    # non-destroy commits (destroys return early via the archive path). Reads
+    # the flag captured in after_save; a nil flag (no save ran, e.g. a bare
+    # touch) is treated as "no relevant change".
+    def relevant_change_absent?
+      !_linear_relevant_change
+    end
+
+    def enqueue_archive_if_captured
+      return unless _linear_archive_issue_id && _linear_archive_account_id
+
+      CollavreLinear::OutboundArchiveJob.perform_later(
+        _linear_archive_issue_id,
+        _linear_archive_account_id
+      )
+    end
+
+    # Mark the IssueLink dirty so the exporter knows a sync is pending.
+    # Only applicable when a link already exists; new creatives have no link yet
+    # (linear_issue_id is NOT NULL so a link cannot be created before the API call).
+    def mark_issue_link_dirty
+      issue_link = linear_issue_links.first
+      issue_link&.update_column(:sync_state, CollavreLinear::IssueLink.sync_states[:dirty])
+    end
+
+    # True when this creative (or any ancestor) carries a ProjectLink, i.e. it
+    # lives inside a subtree that is linked to a Linear project. Only called for
+    # non-destroy commits — the row is still present, so `self_and_ancestors` is
+    # queryable.
+    def linked_subtree?
+      ancestor_ids = self_and_ancestors.pluck(:id)
+      return false if ancestor_ids.empty?
+
+      CollavreLinear::ProjectLink.where(creative_id: ancestor_ids).exists?
+    end
+  end
+end

data/app/services/collavre_linear/client.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module CollavreLinear
+  class Client
+    # Raised when the GraphQL response includes an `errors` array.
+    class Error < StandardError; end
+
+    DEFAULT_ENDPOINT = "https://api.linear.app/graphql"
+
+    # ---------------------------------------------------------------------------
+    # GraphQL operation strings
+    # NOTE: All *Input field names below must be verified against the Live Linear
+    # Apollo schema before production use. Field names are conventional based on
+    # the public Linear GraphQL documentation but have NOT been validated against
+    # the live schema in this implementation.
+    # ---------------------------------------------------------------------------
+
+    # IssueCreateInput fields used: teamId, title, description, parentId,
+    # projectId, stateId, assigneeId, labelIds, priority
+    ISSUE_CREATE = <<~GQL.freeze
+      mutation IssueCreate($input: IssueCreateInput!) {
+        issueCreate(input: $input) {
+          success
+          issue {
+            id
+            identifier
+            updatedAt
+          }
+        }
+      }
+    GQL
+
+    # IssueUpdateInput fields used: title, description, parentId, projectId,
+    # stateId, assigneeId, labelIds, priority (any subset passed as **fields)
+    ISSUE_UPDATE = <<~GQL.freeze
+      mutation IssueUpdate($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
+          success
+          issue {
+            id
+            identifier
+            updatedAt
+          }
+        }
+      }
+    GQL
+
+    # ProjectCreateInput fields used: name, teamIds
+    PROJECT_CREATE = <<~GQL.freeze
+      mutation ProjectCreate($input: ProjectCreateInput!) {
+        projectCreate(input: $input) {
+          success
+          project {
+            id
+          }
+        }
+      }
+    GQL
+
+    # ProjectUpdateInput fields used: name (any subset passed as **fields)
+    PROJECT_UPDATE = <<~GQL.freeze
+      mutation ProjectUpdate($id: String!, $input: ProjectUpdateInput!) {
+        projectUpdate(id: $id, input: $input) {
+          success
+          project {
+            id
+          }
+        }
+      }
+    GQL
+
+    # CommentCreateInput fields used: issueId, body
+    COMMENT_CREATE = <<~GQL.freeze
+      mutation CommentCreate($input: CommentCreateInput!) {
+        commentCreate(input: $input) {
+          success
+          comment {
+            id
+            updatedAt
+          }
+        }
+      }
+    GQL
+
+    # CommentUpdateInput fields used: body
+    COMMENT_UPDATE = <<~GQL.freeze
+      mutation CommentUpdate($id: String!, $input: CommentUpdateInput!) {
+        commentUpdate(id: $id, input: $input) {
+          success
+          comment {
+            id
+            updatedAt
+          }
+        }
+      }
+    GQL
+
+    COMMENT_DELETE = <<~GQL.freeze
+      mutation CommentDelete($id: String!) {
+        commentDelete(id: $id) {
+          success
+        }
+      }
+    GQL
+
+    # WebhookCreateInput fields used: url, secret, teamId, resourceTypes
+    WEBHOOK_CREATE = <<~GQL.freeze
+      mutation WebhookCreate($input: WebhookCreateInput!) {
+        webhookCreate(input: $input) {
+          success
+          webhook {
+            id
+          }
+        }
+      }
+    GQL
+
+    # Archive (soft-delete) a Linear issue by id.
+    ISSUE_ARCHIVE = <<~GQL.freeze
+      mutation IssueArchive($id: String!) {
+        issueArchive(id: $id) {
+          success
+        }
+      }
+    GQL
+
+    # Delete (deregister) a Linear webhook by id.
+    WEBHOOK_DELETE = <<~GQL.freeze
+      mutation WebhookDelete($id: String!) {
+        webhookDelete(id: $id) {
+          success
+        }
+      }
+    GQL
+
+    # Delete (deregister) a webhook from Linear.
+    # @param id [String] Linear webhook UUID
+    # @return [Boolean] success
+    def delete_webhook(id)
+      data = post!(WEBHOOK_DELETE, { id: id })
+      data.dig("webhookDelete", "success") == true
+    end
+
+    # Viewer identity only. Linear's schema exposes no Query field for the OAuth
+    # app actor id of the current token (`applicationWithAuthorization { appActor }`
+    # is not valid — that field is absent and its type carries no appActor), so
+    # app_actor_id stays nil and EchoGuard no-ops. Loops are already prevented
+    # independently by InboundApplier (skip_linear_sync on inbound writes,
+    # IssueLink dedup on create, content_hash on update).
+    VIEWER = <<~GQL.freeze
+      query Viewer {
+        viewer {
+          id
+          organization {
+            id
+          }
+        }
+      }
+    GQL
+
+    # List the workspace teams the token can see (for the link-a-project picker).
+    TEAMS = <<~GQL.freeze
+      query Teams {
+        teams(first: 250) {
+          nodes {
+            id
+            name
+            key
+          }
+        }
+      }
+    GQL
+
+    # List projects with their owning team ids so the picker can scope projects
+    # to the chosen team (a Linear project may belong to more than one team).
+    PROJECTS = <<~GQL.freeze
+      query Projects {
+        projects(first: 250) {
+          nodes {
+            id
+            name
+            teams {
+              nodes { id }
+            }
+          }
+        }
+      }
+    GQL
+
+    def initialize(account)
+      @account = account
+      @endpoint = resolve_endpoint
+    end
+
+    # Create a Linear issue.
+    # @return [Hash] with :id and :identifier
+    def create_issue(team_id:, title:, description: nil, parent_id: nil,
+                     project_id: nil, state_id: nil, assignee_id: nil,
+                     label_ids: [], priority: nil)
+      input = { teamId: team_id, title: title }.tap do |h|
+        h[:description] = description if description
+        h[:parentId]    = parent_id   if parent_id
+        h[:projectId]   = project_id  if project_id
+        h[:stateId]     = state_id    if state_id
+        h[:assigneeId]  = assignee_id if assignee_id
+        h[:labelIds]    = label_ids   if label_ids.any?
+        h[:priority]    = priority    if priority
+      end
+
+      data = post!(ISSUE_CREATE, { input: input })
+      node = data.dig("issueCreate", "issue")
+      symbolize(node)
+    end
+
+    # Update a Linear issue by id.
+    # @param id [String] Linear issue UUID
+    # @param fields [Hash] keyword args mapping to IssueUpdateInput fields
+    # @return [Hash] with :id and :identifier
+    def update_issue(id, **fields)
+      input = camelize_keys(fields)
+      data  = post!(ISSUE_UPDATE, { id: id, input: input })
+      node  = data.dig("issueUpdate", "issue")
+      symbolize(node)
+    end
+
+    # Create a Linear project.
+    # @return [Hash] with :id
+    def create_project(name:, team_ids:)
+      input = { name: name, teamIds: team_ids }
+      data  = post!(PROJECT_CREATE, { input: input })
+      node  = data.dig("projectCreate", "project")
+      symbolize(node)
+    end
+
+    # Update a Linear project by id.
+    # @param id [String] Linear project UUID
+    # @param fields [Hash] keyword args mapping to ProjectUpdateInput fields
+    # @return [Hash] with :id
+    def update_project(id, **fields)
+      input = camelize_keys(fields)
+      data  = post!(PROJECT_UPDATE, { id: id, input: input })
+      node  = data.dig("projectUpdate", "project")
+      symbolize(node)
+    end
+
+    # Archive a Linear issue (soft-delete).
+    # @param id [String] Linear issue UUID
+    # @return [Boolean] success
+    def archive_issue(id)
+      data = post!(ISSUE_ARCHIVE, { id: id })
+      data.dig("issueArchive", "success") == true
+    end
+
+    # Create a comment on a Linear issue.
+    # @return [Hash] with :id
+    def create_comment(issue_id:, body:)
+      input = { issueId: issue_id, body: body }
+      data  = post!(COMMENT_CREATE, { input: input })
+      node  = data.dig("commentCreate", "comment")
+      symbolize(node)
+    end
+
+    # Edit an existing Linear comment's body.
+    # @return [Hash] with :id
+    def update_comment(id:, body:)
+      data = post!(COMMENT_UPDATE, { id: id, input: { body: body } })
+      node = data.dig("commentUpdate", "comment")
+      symbolize(node)
+    end
+
+    # Delete a Linear comment.
+    # @return [Boolean] success
+    def delete_comment(id)
+      data = post!(COMMENT_DELETE, { id: id })
+      data.dig("commentDelete", "success") == true
+    end
+
+    # Fetch the authenticated viewer identity.
+    # app_actor_id is intentionally nil (no Linear query exposes it for the
+    # current token); EchoGuard degrades to a no-op — see VIEWER above.
+    # @return [Hash] with :user_id, :app_actor_id, :organization_id
+    def viewer_and_app_actor
+      data = post!(VIEWER, {})
+      {
+        user_id:         data.dig("viewer", "id"),
+        organization_id: data.dig("viewer", "organization", "id"),
+        app_actor_id:    nil
+      }
+    end
+
+    # List workspace teams for the link picker.
+    # @return [Array<Hash>] each with :id, :name, :key
+    def list_teams
+      data  = post!(TEAMS, {})
+      nodes = data.dig("teams", "nodes") || []
+      nodes.map { |n| symbolize(n) }
+    end
+
+    # List projects for the link picker, each with the ids of its owning teams
+    # so the UI can scope projects to the selected team.
+    # @return [Array<Hash>] each with :id, :name, :team_ids
+    def list_projects
+      data  = post!(PROJECTS, {})
+      nodes = data.dig("projects", "nodes") || []
+      nodes.map do |n|
+        {
+          id:       n["id"],
+          name:     n["name"],
+          team_ids: (n.dig("teams", "nodes") || []).map { |t| t["id"] }
+        }
+      end
+    end
+
+    # Register a webhook with Linear.
+    # WebhookCreateInput fields: url, secret, teamId, resourceTypes
+    # @return [Hash] with :id
+    def register_webhook(url:, secret:, team_id:, resource_types:)
+      input = { url: url, secret: secret, teamId: team_id, resourceTypes: resource_types }
+      data  = post!(WEBHOOK_CREATE, { input: input })
+      node  = data.dig("webhookCreate", "webhook")
+      symbolize(node)
+    end
+
+    private
+
+    attr_reader :account, :endpoint
+
+    # Execute a GraphQL operation and return the `data` hash.
+    # Raises Client::Error if the response contains a top-level `errors` key.
+    def post!(query, variables)
+      uri  = URI.parse(endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 10
+      http.read_timeout = 30
+
+      request = Net::HTTP::Post.new(uri.path.presence || "/")
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Bearer #{fresh_access_token}"
+      request.body = { query: query, variables: variables }.to_json
+
+      response =
+        begin
+          http.request(request)
+        rescue SocketError, SystemCallError, Timeout::Error, IOError,
+               OpenSSL::SSL::SSLError => e
+          # Transport-layer failures (connection refused/reset, DNS, TLS,
+          # open/read timeouts) raise before any GraphQL response exists, so they
+          # bypass the parsed-`errors` path below. Wrap them in Error so the
+          # outbound jobs' `retry_on Client::Error` treats a transient
+          # Linear/network outage as retryable instead of dropping the pending
+          # sync/comment/archive on the first failure.
+          raise Error, "Linear transport error: #{e.class}: #{e.message}"
+        end
+
+      parsed = begin
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        raise Error, "Linear returned non-JSON response (HTTP #{response.code}): #{response.body.to_s[0, 200]}"
+      end
+
+      if parsed["errors"].present?
+        messages = parsed["errors"].map { |e| e["message"] }.join("; ")
+        raise Error, "Linear GraphQL error(s): #{messages}"
+      end
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise Error, "Linear HTTP error: #{response.code} #{response.message}"
+      end
+
+      parsed["data"]
+    end
+
+    # Return a non-expired access token, refreshing via the refresh_token grant
+    # when the current token is expiring soon.
+    #
+    # Guards:
+    #   - no refresh_token present  → use current token (nothing to refresh with)
+    #   - nil token_expires_at      → long-lived token, never triggers a refresh
+    #     (Account#token_expiring_soon? returns false for a nil expiry)
+    def fresh_access_token
+      if account.refresh_token.present? && account.token_expiring_soon?
+        begin
+          CollavreLinear::OAuthTokenService.refresh(account)
+        rescue CollavreLinear::OAuthTokenService::Error,
+               SocketError, SystemCallError, Timeout::Error, IOError,
+               OpenSSL::SSL::SSLError => e
+          # The refresh runs before the GraphQL request, so a transient failure
+          # here (network/TLS/timeout, or a temporary non-2xx from Linear's token
+          # endpoint) raises outside post!'s transport wrap and would bypass the
+          # outbound jobs' retry_on Client::Error, dropping the pending sync. Map
+          # it to Error so a transient outage is retried, not lost.
+          raise Error, "Linear token refresh failed: #{e.class}: #{e.message}"
+        end
+      end
+      account.access_token
+    end
+
+    def resolve_endpoint
+      if defined?(Collavre::IntegrationSettings::Resolver)
+        Collavre::IntegrationSettings::Resolver.get(:linear_api_endpoint).presence
+      end || DEFAULT_ENDPOINT
+    end
+
+    # Convert symbol keys to camelCase strings for GraphQL variables.
+    # e.g. :team_id => "teamId"
+    def camelize_keys(hash)
+      hash.transform_keys { |k| camelize(k.to_s) }
+    end
+
+    def camelize(str)
+      parts = str.split("_")
+      parts[0] + parts[1..].map(&:capitalize).join
+    end
+
+    def symbolize(hash)
+      return {} if hash.nil?
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end