forest_admin_datasource_intercom 1.49.0

data/lib/forest_admin_datasource_intercom/collections/relations.rb

@@ -0,0 +1,294 @@
+module ForestAdminDatasourceIntercom
+  module Collections
+    # Intercom joins nothing, so relation filters must be answered here: the agent publishes a
+    # many-to-one filterable as soon as any target column is. A null foreign key matches no
+    # relation filter, negated ones included, like a join.
+    module Relations # rubocop:disable Metrics/ModuleLength
+      ManyToOneSchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
+      ManyToManySchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema
+      OneToManySchema = ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema
+      Filter = ForestAdminDatasourceToolkit::Components::Query::Filter
+      Projection = ForestAdminDatasourceToolkit::Components::Query::Projection
+      Operators = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+      Branch = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeBranch
+      Leaf = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+
+      # What a relation condition comes to when the target matched no record: no
+      # row can satisfy it. It is a value rather than an empty condition because
+      # the two tiers spell "match nothing" differently -- in memory an `in []`
+      # says it, while Intercom's search DSL has no way to.
+      NOTHING = :matches_nothing
+
+      # The group a relation condition expands into, told apart from a group the
+      # operator wrote. Two things hang on the difference: this one may be
+      # inlined into a parent aggregating the same way -- the level it adds is
+      # one nobody budgeted for -- and a tier refusing it can name the relation
+      # rather than a shape the operator never wrote.
+      class RelationBranch < Branch
+        attr_reader :relation_field
+
+        def initialize(aggregator, conditions, relation_field)
+          @relation_field = relation_field
+          super(aggregator, conditions)
+        end
+      end
+
+      protected
+
+      # Every relation of this package points at a collection keyed by `id` and
+      # is read-only: nothing in this lot writes, and an editable relation would
+      # offer an association the collection cannot perform.
+      #
+      # Published unfilterable where the endpoint filters nothing on the key, so
+      # the interface does not offer the traversal `check_relation_filterable!`
+      # would refuse.
+      def add_many_to_one(name, foreign_collection:, foreign_key:)
+        add_field(name, ManyToOneSchema.new(foreign_collection: foreign_collection,
+                                            foreign_key: foreign_key,
+                                            foreign_key_target: 'id',
+                                            is_read_only: true,
+                                            is_filterable: relation_key_filterable?(foreign_key)))
+      end
+
+      # Served by the agent as `origin_key equals <id>` on the target, which must answer it.
+      def add_one_to_many(name, foreign_collection:, origin_key:)
+        add_field(name, OneToManySchema.new(foreign_collection: foreign_collection,
+                                            origin_key: origin_key,
+                                            origin_key_target: 'id',
+                                            is_read_only: true))
+      end
+
+      def add_many_to_many(name, foreign_collection:, through_collection:, origin_key:, foreign_key:)
+        add_field(name, ManyToManySchema.new(foreign_collection: foreign_collection,
+                                             through_collection: through_collection,
+                                             origin_key: origin_key, origin_key_target: 'id',
+                                             foreign_key: foreign_key, foreign_key_target: 'id',
+                                             is_read_only: true))
+      end
+
+      # `records` are the unprojected rows, where the foreign keys live. One read per target
+      # collection per page, shared by every relation pointing at it.
+      def embed_relations(caller, records, rows, projection)
+        asked = many_to_one_asked(projection)
+        return if asked.empty?
+
+        indexed = indexed_targets(caller, records, asked)
+
+        asked.each do |name, relation, wanted|
+          rows_of_target = indexed[relation.foreign_collection]
+
+          # Nil rather than absent when an id names no record: a teammate who
+          # left the workspace reads as no teammate, not as a broken row. Sliced
+          # back to what this relation asked for, the read having been widened to
+          # the union of what every relation on that collection did.
+          records.each_with_index do |record, index|
+            target_row = rows_of_target[record[relation.foreign_key]]
+            rows[index][name] = target_row&.slice(*wanted)
+          end
+        end
+      end
+
+      # Trades each `relation:field` leaf for a condition on the foreign key, built by the block
+      # from the ids the target matched.
+      def rewrite_relation_conditions(caller, node, &builder)
+        case node
+        when Branch then rewrite_branch(caller, node, &builder)
+        when Leaf then relation_leaf?(node) ? rewrite_relation_leaf(caller, node, &builder) : node
+        else node
+        end
+      end
+
+      private
+
+      def relation_leaf?(node)
+        node.is_a?(Leaf) && node.field.to_s.include?(':')
+      end
+
+      def relations_asked(projection)
+        Projection.new(Array(projection).map(&:to_s)).relations
+      end
+
+      # The many-to-one relations the projection named, each with the columns it
+      # asked of its target. The target's own key travels with them whether or
+      # not it was asked for: it is what the rows are indexed by here, and what
+      # makes the nested row a link rather than a label in the interface.
+      def many_to_one_asked(projection)
+        relations_asked(projection).filter_map do |relation_name, sub_projection|
+          relation = fields[relation_name]
+          next unless relation.is_a?(ManyToOneSchema)
+
+          columns = Array(sub_projection).map(&:to_s)
+          refuse_two_hop_projection!(relation_name, relation, columns)
+
+          [relation_name, relation, columns.union([relation.foreign_key_target])]
+        end
+      end
+
+      # `admin_assignee:teams:name` is a projection Forest's own parser builds
+      # and this cannot answer: it nests one target row under the relation name,
+      # not a tree of them, so the second hop would be dropped by the target's
+      # projection and the column would come back missing from a row that looks
+      # complete. Refused by name, like the filter that reaches that deep --
+      # `refuse_two_hops!` is its counterpart.
+      def refuse_two_hop_projection!(relation_name, relation, columns)
+        deep = columns.select { |column| column.include?(':') }
+        return if deep.empty?
+
+        raise UnsupportedOperatorError,
+              "#{name} cannot read #{deep.map { |column| "#{relation_name}:#{column}".inspect }.join(", ")}: it " \
+              'reaches through two relations, and this datasource resolves one. Read the column from a record ' \
+              "page of #{relation.foreign_collection}, one hop away."
+      end
+
+      def indexed_targets(caller, records, asked)
+        asked.group_by { |_, relation, _| relation.foreign_collection }
+             .transform_values { |group| target_rows(caller, records, group) }
+      end
+
+      # Past what the target resolves at all, refused: a partly resolved page would show nil where
+      # a record exists.
+      def target_rows(caller, records, group)
+        relation = group.first[1]
+        ids = group.flat_map { |_, rel, _| records.filter_map { |record| record[rel.foreign_key] } }.uniq
+        return {} if ids.empty?
+
+        collection = foreign_collection(relation)
+        refuse_relation_fan_out!(group, collection, ids.size) if beyond_reach?(collection, ids.size)
+
+        target = relation.foreign_key_target
+        wanted = Projection.new(group.flat_map { |_, _, columns| columns }.uniq)
+
+        read_targets(caller, collection, target, ids, wanted).to_h { |row| [row[target], row] }
+      end
+
+      def beyond_reach?(collection, count)
+        limit = collection.max_resolvable_ids
+
+        !limit.nil? && count > limit
+      end
+
+      def read_targets(caller, collection, target, ids, wanted)
+        chunk = collection.ids_per_read
+        slices = chunk ? ids.each_slice(chunk).to_a : [ids]
+
+        slices.flat_map do |slice|
+          collection.list(caller, Filter.new(condition_tree: Leaf.new(target, Operators::IN, slice)), wanted)
+        end
+      end
+
+      # Names the relations rather than the key they resolve to: what the
+      # operator can act on is the column they put in the view or the export,
+      # and how many rows they asked for at once.
+      def refuse_relation_fan_out!(group, collection, count)
+        asked = group.map { |relation_name, _, _| relation_name }.join(', ')
+
+        raise UnsupportedOperatorError,
+              "#{name} cannot resolve #{asked} over this read: it names #{count} distinct #{collection.name} " \
+              'records and Intercom has no bulk read for that collection, so this resolves at most ' \
+              "#{collection.max_resolvable_ids} of them per read -- one request each. Read fewer rows at a time, " \
+              'or leave the relation out of the projection: a relation resolved for part of a page would show no ' \
+              'record where one exists.'
+      end
+
+      def rewrite_branch(caller, branch, &builder)
+        rewritten = Array(branch.conditions).map { |node| rewrite_relation_conditions(caller, node, &builder) }
+
+        if branch.aggregator.to_s.casecmp('or').zero?
+          kept = rewritten.reject { |node| node == NOTHING }
+          kept.empty? ? NOTHING : Branch.new(branch.aggregator, absorb_groups(branch.aggregator, kept))
+        elsif rewritten.include?(NOTHING)
+          NOTHING
+        else
+          Branch.new(branch.aggregator, absorb_groups(branch.aggregator, rewritten))
+        end
+      end
+
+      # `or(x, or(a, b))` becomes `or(x, a, b)`, saving the nesting level a relation expansion
+      # adds. Only relation groups are inlined, never groups the operator wrote.
+      def absorb_groups(aggregator, nodes)
+        absorbed = nodes.flat_map do |node|
+          inlinable_group?(node, aggregator) ? Array(node.conditions) : [node]
+        end
+
+        absorb_relation_group?(absorbed.size) ? absorbed : nodes
+      end
+
+      def inlinable_group?(node, aggregator)
+        node.is_a?(RelationBranch) && node.aggregator.to_s.casecmp(aggregator.to_s).zero?
+      end
+
+      # Hook for a tier that bounds how many conditions a group may hold: past
+      # that, the nested form is the one that fits, and the level it costs is
+      # spent rather than the width.
+      def absorb_relation_group?(_size) = true
+
+      def rewrite_relation_leaf(caller, leaf)
+        name, path = leaf.field.to_s.split(':', 2)
+        relation = fields[name]
+        refuse_unknown_relation!(leaf, name) unless relation.is_a?(ManyToOneSchema)
+        refuse_two_hops!(leaf) if path.include?(':')
+
+        check_relation_filterable!(leaf, relation)
+
+        ids = matching_ids(caller, relation, Leaf.new(path, leaf.operator, leaf.value))
+        return NOTHING if ids.empty?
+
+        yield(relation.foreign_key, ids, leaf)
+      end
+
+      # Hooks for a tier that cannot filter on every foreign key it declares a
+      # relation on. Answered before the target is read: a refusal that spends a
+      # request first costs exactly what it refuses to do.
+      def relation_key_filterable?(_key) = true
+
+      def check_relation_filterable!(_leaf, _relation); end
+
+      # Which records of the target the condition names, asked of the target
+      # itself: it owns what its columns can be filtered with, and it answers
+      # over every record Intercom holds rather than over a page of them.
+      def matching_ids(caller, relation, leaf)
+        target = relation.foreign_key_target
+        filter = Filter.new(condition_tree: leaf, page: match_page)
+
+        foreign_collection(relation)
+          .list(caller, filter, Projection.new([target]))
+          .filter_map { |row| row[target] }
+          .uniq
+      end
+
+      # How much of the target a relation condition may read; unbounded for in-memory targets.
+      def match_page = nil
+
+      # The target as the datasource holds it, undecorated -- so a permission
+      # scope or a segment defined on the target does not narrow what a relation
+      # resolves. That is how a native datasource behaves too: it joins the table
+      # without applying the scopes of the collection mapped to it.
+      def foreign_collection(relation)
+        datasource.get_collection(relation.foreign_collection)
+      end
+
+      # Either a name this collection carries no relation under -- a condition
+      # from a scope or a segment written against another schema -- or a
+      # many-to-many, which is published unfilterable: resolving one would mean
+      # reading the collection it travels through once per value.
+      def refuse_unknown_relation!(leaf, relation_name)
+        filterable = fields.select { |_, field| field.is_a?(ManyToOneSchema) }.keys
+
+        raise UnsupportedOperatorError,
+              "#{name} cannot filter #{leaf.field.inspect}: #{relation_name.inspect} is not a relation it filters " \
+              "through. #{filterable.empty? ? "It has none." : "Those it does: #{filterable.join(", ")}."} Filter " \
+              'on a column of the collection next door instead.'
+      end
+
+      # Two hops would mean resolving a relation of a relation, one read per
+      # level, and nothing in this datasource publishes a filter that deep -- a
+      # many-to-many is published unfilterable. It is refused by name rather than
+      # half-answered.
+      def refuse_two_hops!(leaf)
+        raise UnsupportedOperatorError,
+              "#{name} cannot filter #{leaf.field.inspect}: it reaches through two relations, and this datasource " \
+              'resolves one. Filter on a column of the collection next door instead.'
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_intercom/collections/team.rb

@@ -0,0 +1,70 @@
+module ForestAdminDatasourceIntercom
+  module Collections
+    # The inbox teams a conversation can be assigned to, rather than a single
+    # teammate.
+    class Team < FetchAllCollection
+      def initialize(datasource)
+        super(datasource, 'IntercomTeam')
+      end
+
+      protected
+
+      # Like `/admins`, `/teams` uses its own key instead of the `data` envelope.
+      def fetch_all
+        client.fetch_all('teams', list_key: 'teams')
+      end
+
+      def serialize(team)
+        attrs = team.is_a?(Hash) ? team : {}
+
+        { 'id' => stringify_id(attrs['id']),
+          'name' => attrs['name'],
+          # Not a column: it is what the names below are read from, and what the
+          # membership collection turns into the relation. Intercom types these
+          # as numbers here and as strings on the admin itself, so they are
+          # stringified for both sides to carry the same id.
+          'admin_ids' => Array(attrs['admin_ids']).map { |id| stringify_id(id) },
+          'admin_names' => nil }
+      end
+
+      # The teammates of the team, by name, and only when a projection asked for
+      # them: one read of `/admins` for the whole page, never one per team. A
+      # token that cannot read the teammates costs the column and nothing else.
+      def enrich(records, rows, projection)
+        return unless column_asked?(projection, 'admin_names')
+
+        names = admin_names
+        return if names.nil?
+
+        records.each_with_index do |record, index|
+          rows[index]['admin_names'] = Array(record['admin_ids']).filter_map { |id| names[id] }
+        end
+      end
+
+      private
+
+      def admin_names
+        client.fetch_all('admins', list_key: 'admins')
+              .to_h { |admin| [stringify_id(admin['id']), admin['name']] }
+      rescue APIError => e
+        ForestAdminDatasourceIntercom.logger.warn(
+          "[forest_admin_datasource_intercom] #{name} could not read the teammates of the workspace (HTTP " \
+          "#{e.status || "-"}); the names are left unknown. The relation to IntercomAdmin is unaffected."
+        )
+        nil
+      end
+
+      def define_schema
+        add_column('id', 'String', is_primary_key: true)
+        add_column('name', 'String')
+        # A list, so neither filterable nor sortable -- as the array of ids it
+        # replaces was. It reads the team without a join; the relation below is
+        # what navigates it, and filtering happens on the Admins collection.
+        add_column('admin_names', 'Json')
+        add_many_to_many('admins', foreign_collection: 'IntercomAdmin',
+                                   through_collection: 'IntercomTeamMembership',
+                                   origin_key: 'team_id', foreign_key: 'admin_id')
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_intercom/collections/team_membership.rb

@@ -0,0 +1,51 @@
+module ForestAdminDatasourceIntercom
+  module Collections
+    # Synthetic through-collection for the Team <-> Admin many-to-many, which Intercom has no
+    # resource for. Pairs whose teammate `/admins` no longer answers are dropped: `admin_ids`
+    # keeps naming a teammate who left until Intercom drops the pair.
+    class TeamMembership < FetchAllCollection
+      def initialize(datasource)
+        super(datasource, 'IntercomTeamMembership')
+      end
+
+      protected
+
+      def fetch_all
+        admin_ids = client.fetch_all('admins', list_key: 'admins')
+                          .filter_map { |admin| stringify_id(admin['id']) if admin.is_a?(Hash) }.to_set
+        client.fetch_all('teams', list_key: 'teams').flat_map { |team| pairs_of(team, admin_ids) }
+      end
+
+      # Keyed by both ids rather than by a counter: a related list is read over
+      # two requests, and a key that changed between them would move the rows
+      # under the operator.
+      def serialize(pair)
+        { 'id' => "#{pair["team_id"]}:#{pair["admin_id"]}",
+          'team_id' => pair['team_id'],
+          'admin_id' => pair['admin_id'] }
+      end
+
+      private
+
+      def pairs_of(team, admin_ids)
+        return [] unless team.is_a?(Hash)
+
+        team_id = stringify_id(team['id'])
+        return [] if team_id.nil?
+
+        Array(team['admin_ids']).filter_map do |admin_id|
+          id = stringify_id(admin_id)
+          { 'team_id' => team_id, 'admin_id' => id } if admin_ids.include?(id)
+        end
+      end
+
+      def define_schema
+        add_column('id', 'String', is_primary_key: true)
+        add_column('team_id', 'String')
+        add_column('admin_id', 'String')
+        add_many_to_one('team', foreign_collection: 'IntercomTeam', foreign_key: 'team_id')
+        add_many_to_one('admin', foreign_collection: 'IntercomAdmin', foreign_key: 'admin_id')
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_intercom/collections/ticket/derived_columns.rb

@@ -0,0 +1,130 @@
+module ForestAdminDatasourceIntercom
+  module Collections
+    class Ticket < CursorCollection
+      # Derived from the parts: a ticket has no `statistics` block (measured on 81 142 tickets). Display only
+      # for good: /tickets/search filters on neither and silently ignores a sort on them.
+      module DerivedColumns
+        # A ticket is not "closed" on Intercom, it enters a state whose category
+        # is resolved.
+        RESOLVED = 'resolved'.freeze
+
+        # Matched on the prefix, never on the full `ticket_state_updated_by_admin`
+        # the sample showed: a workspace running workflows closes tickets through
+        # other variants of the same event, and a closure nobody can see is worse
+        # than a column nobody offers.
+        STATE_CHANGE_PREFIX = 'ticket_state_updated'.freeze
+
+        # A reply to the customer. A `note` is an internal touch, not an answer:
+        # counting it would name as "last responder" someone who never wrote to
+        # the person waiting.
+        REPLY_PART = 'comment'.freeze
+
+        # The columns a truncated timeline leaves unknown rather than empty, and
+        # therefore the ones whose presence in a projection is worth a warning.
+        CLOSURE_COLUMNS = %w[closed_at closed_by_name].freeze
+
+        private
+
+        def define_derived_columns
+          add_column('closed_at', 'Date')
+          add_column('closed_by_name', 'String')
+          add_column('last_reply_at', 'Date')
+          add_column('last_responder_name', 'String')
+          # `admin` or `contact`: whether the last word came from the team or
+          # from the customer is what tells a queue who owes the next one.
+          add_column('last_responder_type', 'String')
+        end
+
+        def derived_columns_for(attrs)
+          parts = parts_of(attrs)
+          closure = last_closure(parts)
+          reply = last_reply(parts)
+
+          { 'closed_at' => stamp(closure&.dig('created_at')),
+            'closed_by_name' => author_of(closure)['name'],
+            'last_reply_at' => stamp(reply&.dig('created_at')),
+            'last_responder_name' => author_of(reply)['name'],
+            'last_responder_type' => author_of(reply)['type'] }
+        end
+
+        # The hook of the base's `enrich`: nothing to read here, since
+        # `serialize` already derived everything. What is left is telling the
+        # operator when a value is missing because the timeline was truncated
+        # rather than because the event never happened.
+        def embed_derived_columns(records, _rows, projection)
+          return unless any_column_asked?(projection, CLOSURE_COLUMNS)
+
+          unknown = records.count { |record| closure_unknown?(record) }
+          warn_unknown_closures(unknown) if unknown.positive?
+        end
+
+        # A resolved ticket with no closure in hand, on a timeline Intercom
+        # truncated: the date is *unknown*, not absent. A Date column cannot say
+        # that, so the log does.
+        def closure_unknown?(record)
+          state = record['ticket_state'].is_a?(Hash) ? record['ticket_state'] : {}
+          return false unless state['category'] == RESOLVED
+
+          last_closure(parts_of(record)).nil? && truncated?(record)
+        end
+
+        # Intercom keeps the 500 most recent parts of a ticket. Past that, the
+        # transition that closed it may have fallen out of the window.
+        def truncated?(record)
+          total = parts_total(record)
+          total ? total > Array(parts_of(record)).size : false
+        end
+
+        def last_closure(parts)
+          closures = Array(parts).select { |part| state_change?(part) && part['ticket_state'] == RESOLVED }
+
+          closures.max_by { |part| part['created_at'].to_i }
+        end
+
+        # A part can record a transition to the state the ticket was already in
+        # -- measured -- and that is not an event.
+        def state_change?(part)
+          part['part_type'].to_s.start_with?(STATE_CHANGE_PREFIX) &&
+            part['ticket_state'] != part['previous_ticket_state']
+        end
+
+        def last_reply(parts)
+          Array(parts).select { |part| part['part_type'] == REPLY_PART }.max_by { |part| part['created_at'].to_i }
+        end
+
+        def author_of(part)
+          author = (part || {})['author']
+          author.is_a?(Hash) ? author : {}
+        end
+
+        # nil rather than an empty list when the payload carries no parts: an
+        # empty thread would read as a ticket nothing happened to.
+        def parts_of(record)
+          container = (record || {})['ticket_parts']
+          parts = container['ticket_parts'] if container.is_a?(Hash)
+          parts.is_a?(Array) ? parts : nil
+        end
+
+        def parts_total(record)
+          container = (record || {})['ticket_parts']
+          container.is_a?(Hash) ? container['total_count'] : nil
+        end
+
+        def warn_truncated_timelines(truncated)
+          ForestAdminDatasourceIntercom.logger.warn(
+            "[forest_admin_datasource_intercom] #{name}: the timeline of #{truncated} ticket(s) of this page " \
+            'holds only their 500 most recent parts, Intercom keeping no more. Earlier events are left out.'
+          )
+        end
+
+        def warn_unknown_closures(unknown)
+          ForestAdminDatasourceIntercom.logger.warn(
+            "[forest_admin_datasource_intercom] #{name}: #{unknown} resolved ticket(s) of this page show no " \
+            'closure date because Intercom truncated their timeline at 500 parts, not because they were never ' \
+            'closed. The column is unknown for those rows.'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_intercom/collections/ticket/serializer.rb

@@ -0,0 +1,70 @@
+module ForestAdminDatasourceIntercom
+  module Collections
+    class Ticket < CursorCollection
+      # One Intercom ticket flattened into the row the schema declares. Nothing
+      # here reads a sub-resource: the state, the type and the attributes all
+      # travel with the ticket.
+      module Serializer
+        protected
+
+        # Intercom keys the attribute values by **name**, which is what lets a
+        # single collection display the union of every ticket type's -- and what
+        # stops it from filtering on them, the filter being written by an id
+        # that differs from one type to the next. A ticket of another type
+        # simply does not carry the key, and the column reads as empty.
+        def serialize(ticket)
+          attrs = ticket.is_a?(Hash) ? ticket : {}
+
+          native(attrs)
+            .merge(state_of(attrs))
+            .merge(type_of(attrs['ticket_type']))
+            .merge(contact_columns_for(attrs))
+            .merge(ticket_attribute_values(attrs))
+            .merge(derived_columns_for(attrs))
+        end
+
+        private
+
+        def native(attrs)
+          { 'id' => stringify_id(attrs['id']),
+            'ticket_id' => stringify_id(attrs['ticket_id']),
+            'category' => attrs['category'],
+            'open' => attrs['open'],
+            'is_shared' => attrs['is_shared'],
+            'created_at' => stamp(attrs['created_at']),
+            'updated_at' => stamp(attrs['updated_at']),
+            'admin_assignee_id' => stringify_id(attrs['admin_assignee_id']),
+            'team_assignee_id' => stringify_id(attrs['team_assignee_id']),
+            'company_id' => stringify_id(attrs['company_id']),
+            'part_count' => parts_total(attrs) }
+        end
+
+        def state_of(attrs)
+          state = attrs['ticket_state'].is_a?(Hash) ? attrs['ticket_state'] : {}
+
+          # `internal_label` is what the support team reads. The category and the
+          # customer-facing label are a hop away, on the `state` relation.
+          { 'state_id' => stringify_id(state['id']),
+            'state_label' => state['internal_label'],
+            'previous_state_id' => stringify_id(attrs['previous_ticket_state_id']) }
+        end
+
+        def ticket_attribute_values(attrs)
+          values = attribute_values(attrs['ticket_attributes'])
+          type_id = stringify_id(attrs.dig('ticket_type', 'id')) if attrs['ticket_type'].is_a?(Hash)
+
+          attribute_columns.each do |attribute|
+            values[attribute.column_name] = nil if Array(attribute.conflicting_ticket_types).include?(type_id)
+          end
+          values
+        end
+
+        def type_of(ticket_type)
+          attrs = ticket_type.is_a?(Hash) ? ticket_type : {}
+
+          { 'ticket_type_id' => stringify_id(attrs['id']), 'ticket_type_name' => attrs['name'] }
+        end
+      end
+    end
+  end
+end