forest_admin_datasource_zendesk 1.29.2 → 1.30.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0760d5ef358744a243f766144ffe95589066dd1e0b02da42ab3079dea96d5a2f
-  data.tar.gz: 97bfcb9aa7742bc7e4f0908d976a1881664ac38723f93f0c0570df885dce2e2d
+  metadata.gz: 84b08e9f27307b2c63ac820be8b0a8c29d23272837bfc629111e66f5d06fd720
+  data.tar.gz: 997953ff0ca7596931d90f7eb48e53b8f010632822c5ad5abe2ff0c6e79fe609
 SHA512:
-  metadata.gz: a1b4934f135351ddeabdf5ca15c9aa2199d55e0dfba5b90c165f5510bbb5f217674c1aba3f72f4cb17454b1a03e76e5a367cc099843bc0ed961542d3b47cc5e1
-  data.tar.gz: 3bdf4e7f612ad7f9cb54622bfeac44e24ad7d0f0bc451d4805b8e1ab3ced56dc6885e1add343e6824a0dd5dde96782ed72bf2271eee6de2a0de9559dcde8b596
+  metadata.gz: b3dd9d667a4bcd0bed95823923ae71ad05ad9b628fc9bd34d0b362ab352fda498c77e3863bf74e45e5a1b105ae7eae1abf0284c0c3be4f16cd0e286ae2daf2fd
+  data.tar.gz: a044e0316cf61345d51d024214b394f66c503e69b01e6a473a07b16837cfc1d4ba0b696ce496aeb35cdf707d01b13d694062c9556cbf34ad08c2732fade9b3d6

data/lib/forest_admin_datasource_zendesk/client/writes.rb

@@ -16,17 +16,30 @@ module ForestAdminDatasourceZendesk
       private
 
       def post_resource(path, key, attributes)
-        must_succeed("create(#{path})") do
-          body = api.connection.post(path) { |req| req.body = { key => attributes } }.body
-          body[key] || body
+        op = "create(#{path})"
+        body = must_succeed(op) do
+          api.connection.post(path) { |req| req.body = { key => attributes } }.body
         end
+        extract_resource(body, key, op)
       end
 
       def put_resource(path, key, id, attributes)
-        must_succeed("update(#{path}/#{id})") do
-          body = api.connection.put("#{path}/#{id}") { |req| req.body = { key => attributes } }.body
-          body[key] || body
+        op = "update(#{path}/#{id})"
+        body = must_succeed(op) do
+          api.connection.put("#{path}/#{id}") { |req| req.body = { key => attributes } }.body
         end
+        extract_resource(body, key, op)
+      end
+
+      # Zendesk wraps create/update responses in `{ "<resource>": { ... } }`.
+      # An empty or differently-shaped body means the API contract broke —
+      # surface a typed error rather than handing back a confusing envelope.
+      def extract_resource(body, key, operation)
+        resource = body[key] if body.is_a?(Hash)
+        return resource if resource.is_a?(Hash)
+
+        raise APIError,
+              "Zendesk API #{operation} returned an unexpected body shape (missing '#{key}'): #{body.inspect}"
       end
 
       def delete_resource(path, id)

data/lib/forest_admin_datasource_zendesk/collections/ticket/schema_definition.rb

@@ -18,11 +18,14 @@ module ForestAdminDatasourceZendesk
           add_field('description', ColumnSchema.new(column_type: 'String', filter_operators: [],
                                                     is_read_only: false, is_sortable: false))
           add_field('status', ColumnSchema.new(column_type: 'Enum', filter_operators: STRING_OPS,
-                                               enum_values: ENUM_STATUS, is_read_only: false, is_sortable: true))
+                                               enum_values: TicketEnums::STATUS, is_read_only: false,
+                                               is_sortable: true))
           add_field('priority', ColumnSchema.new(column_type: 'Enum', filter_operators: STRING_OPS,
-                                                 enum_values: ENUM_PRIORITY, is_read_only: false, is_sortable: true))
+                                                 enum_values: TicketEnums::PRIORITY, is_read_only: false,
+                                                 is_sortable: true))
           add_field('ticket_type', ColumnSchema.new(column_type: 'Enum', filter_operators: STRING_OPS,
-                                                    enum_values: ENUM_TYPE, is_read_only: false, is_sortable: true))
+                                                    enum_values: TicketEnums::TYPE, is_read_only: false,
+                                                    is_sortable: true))
           add_field('requester_id', ColumnSchema.new(column_type: 'Number', filter_operators: NUMBER_OPS,
                                                      is_read_only: false, is_sortable: true))
           add_field('assignee_id', ColumnSchema.new(column_type: 'Number', filter_operators: NUMBER_OPS,

data/lib/forest_admin_datasource_zendesk/collections/ticket.rb

@@ -8,10 +8,6 @@ module ForestAdminDatasourceZendesk
 
       ManyToOneSchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
 
-      ENUM_STATUS   = %w[new open pending hold solved closed].freeze
-      ENUM_PRIORITY = %w[low normal high urgent].freeze
-      ENUM_TYPE     = %w[problem incident question task].freeze
-
       ZENDESK_SORTABLE = {
         'updated_at' => 'updated_at',
         'created_at' => 'created_at',

data/lib/forest_admin_datasource_zendesk/collections/user.rb

@@ -6,6 +6,8 @@ module ForestAdminDatasourceZendesk
       ManyToOneSchema = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
       OneToManySchema = ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema
       ENUM_ROLE       = %w[end-user agent admin].freeze
+      BASE_ATTR_KEYS  = %w[id email name role phone organization_id time_zone locale verified suspended
+                           created_at updated_at].freeze
 
       ZENDESK_SORTABLE = {
         'created_at' => 'created_at',
@@ -100,22 +102,11 @@ module ForestAdminDatasourceZendesk
 
       def serialize(user)
         attrs = attrs_of(user)
-        result = base_attributes(attrs)
+        result = BASE_ATTR_KEYS.to_h { |k| [k, attrs[k]] }
         user_fields = attrs['user_fields'] || {}
         @custom_fields.each { |cf| result[cf[:column_name]] = user_fields[cf[:zendesk_key]] }
         result
       end
-
-      def base_attributes(attrs)
-        {
-          'id' => attrs['id'], 'email' => attrs['email'], 'name' => attrs['name'],
-          'role' => attrs['role'], 'phone' => attrs['phone'],
-          'organization_id' => attrs['organization_id'],
-          'time_zone' => attrs['time_zone'], 'locale' => attrs['locale'],
-          'verified' => attrs['verified'], 'suspended' => attrs['suspended'],
-          'created_at' => attrs['created_at'], 'updated_at' => attrs['updated_at']
-        }
-      end
     end
   end
 end

data/lib/forest_admin_datasource_zendesk/plugins/close_ticket/errors.rb

@@ -0,0 +1,34 @@
+module ForestAdminDatasourceZendesk
+  module Plugins
+    class CloseTicket
+      # Decoding helpers for Zendesk's structured update-error payloads.
+      module Errors
+        module_function
+
+        # Zendesk refuses any update on a closed ticket with this exact
+        # wording on the `status` field — detected so we can swap the raw
+        # stack for a clean message.
+        ALREADY_CLOSED_DESCRIPTION = 'closed prevents ticket update'.freeze
+
+        def already_closed?(error)
+          invalid = unwrap_record_invalid(error)
+          return false unless invalid
+
+          status_errors = invalid.errors.is_a?(Hash) ? Array(invalid.errors['status']) : []
+          status_errors.any? do |entry|
+            entry.is_a?(Hash) && entry['description'].to_s.include?(ALREADY_CLOSED_DESCRIPTION)
+          end
+        end
+
+        def unwrap_record_invalid(error)
+          while error
+            return error if error.is_a?(ZendeskAPI::Error::RecordInvalid)
+
+            error = error.cause
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_zendesk/plugins/close_ticket/messages.rb

@@ -0,0 +1,41 @@
+module ForestAdminDatasourceZendesk
+  module Plugins
+    class CloseTicket
+      module Messages
+        module_function
+
+        def success(succeeded, already_closed, failed, status)
+          [succeeded_phrase(succeeded, status), already_closed_phrase(already_closed),
+           failed_phrase(failed)].compact.join(' ')
+        end
+
+        def error(failed, status)
+          verb = status == 'closed' ? 'close' : 'mark as solved'
+          return "Failed to #{verb} ticket ##{failed.first.first}: #{failed.first.last}" if failed.size == 1
+
+          "Failed to #{verb} all #{failed.size} tickets. First error: #{failed.first.last}"
+        end
+
+        def succeeded_phrase(succeeded, status)
+          return nil if succeeded.empty?
+
+          verb = status == 'closed' ? 'closed' : 'marked as solved'
+          succeeded.size == 1 ? "Ticket ##{succeeded.first} #{verb}." : "#{succeeded.size} tickets #{verb}."
+        end
+
+        def already_closed_phrase(already_closed)
+          return nil if already_closed.empty?
+          return "Ticket ##{already_closed.first} was already closed." if already_closed.size == 1
+
+          "#{already_closed.size} tickets were already closed: #{already_closed.join(", ")}."
+        end
+
+        def failed_phrase(failed)
+          return nil if failed.empty?
+
+          "#{failed.size} failed: #{failed.map(&:first).join(", ")}."
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_zendesk/plugins/close_ticket.rb

@@ -0,0 +1,123 @@
+module ForestAdminDatasourceZendesk
+  module Plugins
+    # The Zendesk ticket id is read from a configurable column on the host
+    # record(s); Zendesk sometimes rejects the direct `open -> closed`
+    # transition so failures are surfaced per-id rather than retried.
+    class CloseTicket < ForestAdminDatasourceCustomizer::Plugins::Plugin
+      BaseAction      = ForestAdminDatasourceCustomizer::Decorators::Action::BaseAction
+      ActionScope     = ForestAdminDatasourceCustomizer::Decorators::Action::Types::ActionScope
+      ForestException = ForestAdminDatasourceToolkit::Exceptions::ForestException
+
+      STATUSES = %w[solved closed].freeze
+      SCOPE_KEYS = %i[single bulk].freeze
+
+      NAMES = {
+        'solved' => { single: 'Mark Zendesk ticket as solved',
+                      bulk: 'Mark selected Zendesk tickets as solved' }.freeze,
+        'closed' => { single: 'Mark Zendesk ticket as closed',
+                      bulk: 'Mark selected Zendesk tickets as closed' }.freeze
+      }.freeze
+
+      SCOPES = { single: ActionScope::SINGLE, bulk: ActionScope::BULK }.freeze
+
+      def run(_datasource_customizer, collection_customizer = nil, options = {})
+        datasource = options[:datasource]
+        ticket_id_field = options[:ticket_id_field]
+        raise ForestException, 'CloseTicket plugin requires :datasource' unless datasource
+        raise ForestException, 'CloseTicket plugin requires :ticket_id_field' unless ticket_id_field
+        raise ForestException, 'CloseTicket plugin requires a collection' unless collection_customizer
+
+        statuses = normalize_statuses(options[:statuses])
+        scopes   = normalize_scopes(options[:scopes])
+
+        variants(statuses, scopes).each do |name, status, scope|
+          collection_customizer.add_action(name, build_action(datasource, status, scope, ticket_id_field))
+        end
+      end
+
+      private
+
+      def normalize_statuses(value)
+        normalize(value, :to_s, STATUSES, 'statuses')
+      end
+
+      def normalize_scopes(value)
+        normalize(value, :to_sym, SCOPE_KEYS, 'scopes')
+      end
+
+      def normalize(value, cast, allowed, label)
+        list = Array(value).map(&cast).uniq
+        list = allowed if list.empty?
+        unknown = list - allowed
+        return list if unknown.empty?
+
+        raise ForestException,
+              "Unknown CloseTicket #{label}: #{unknown.join(", ")}. Allowed: #{allowed.join(", ")}."
+      end
+
+      def variants(statuses, scopes)
+        statuses.flat_map do |status|
+          scopes.map { |scope_key| [NAMES[status][scope_key], status, SCOPES[scope_key]] }
+        end
+      end
+
+      def build_action(datasource, status, scope, ticket_id_field)
+        BaseAction.new(scope: scope, &executor(datasource, status, ticket_id_field))
+      end
+
+      def executor(datasource, status, ticket_id_field)
+        lambda do |context, result_builder|
+          ids = resolve_ticket_ids(context, ticket_id_field)
+          next result_builder.error(message: "No Zendesk ticket id found in '#{ticket_id_field}'.") if ids.empty?
+
+          succeeded, already_closed, failed = apply_status(datasource, ids, status)
+
+          # Closed tickets can't be reopened to 'solved'; fold into failures.
+          if status == 'solved'
+            failed += already_closed.map { |id| [id, 'ticket is already closed (cannot reopen to mark as solved)'] }
+            already_closed = []
+          end
+
+          if succeeded.empty? && already_closed.empty?
+            result_builder.error(message: Messages.error(failed, status))
+          else
+            result_builder.success(message: Messages.success(succeeded, already_closed, failed, status))
+          end
+        end
+      end
+
+      def resolve_ticket_ids(context, ticket_id_field)
+        records = context.get_records([ticket_id_field])
+        records.filter_map { |r| r[ticket_id_field.to_s] }
+      rescue StandardError => e
+        ForestAdminDatasourceZendesk.logger.warn(
+          "[forest_admin_datasource_zendesk] failed to resolve ticket ids from '#{ticket_id_field}': " \
+          "#{e.class}: #{e.message}"
+        )
+        []
+      end
+
+      # Per-id rescue so a single transition rejection doesn't abort bulk.
+      def apply_status(datasource, ids, status)
+        succeeded = []
+        already_closed = []
+        failed = []
+        ids.each do |id|
+          datasource.client.update_ticket(id, 'status' => status)
+          succeeded << id
+        rescue StandardError => e
+          if Errors.already_closed?(e)
+            already_closed << id
+          else
+            ForestAdminDatasourceZendesk.logger.warn(
+              "[forest_admin_datasource_zendesk] failed to set ticket ##{id} to '#{status}': " \
+              "#{e.class}: #{e.message}"
+            )
+            failed << [id, "#{e.class}: #{e.message}"]
+          end
+        end
+        [succeeded, already_closed, failed]
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_zendesk/plugins/create_ticket_with_notification/form_builder.rb

@@ -0,0 +1,149 @@
+require 'cgi'
+
+module ForestAdminDatasourceZendesk
+  module Plugins
+    class CreateTicketWithNotification
+      module FormBuilder
+        FieldType = ForestAdminDatasourceCustomizer::Decorators::Action::Types::FieldType
+
+        NO_TEMPLATE = 'No template'.freeze
+        TOKEN_RE = /\{\{\s*record\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/
+
+        module_function
+
+        # ActionCollectionDecorator rejects forms that mix Page elements with
+        # non-Page elements, so each mode (flat / wizard) stays homogeneous.
+        def build(opts)
+          body = body_fields(opts)
+          return body if opts[:email_templates].empty?
+
+          [
+            { type: 'Layout', component: 'Page', next_button_label: 'Continue',
+              elements: [template_field(opts[:email_templates])] },
+            { type: 'Layout', component: 'Page', previous_button_label: 'Back',
+              elements: body }
+          ]
+        end
+
+        def body_fields(opts)
+          fields = [requester_field(opts[:requester_email_default]),
+                    subject_field(opts[:default_subject]),
+                    message_field(opts[:default_message], opts[:email_templates])]
+          fields << priority_field unless present?(opts[:priority_override])
+          fields << type_field unless present?(opts[:type_override])
+          fields << internal_note_field if opts[:show_internal_note]
+          fields
+        end
+
+        def requester_field(default)
+          { type: FieldType::STRING, label: 'Requester email', is_required: true,
+            description: 'Email of the Zendesk requester. Pre-filled from the selected record when available.',
+            default_value: requester_default(default) }
+        end
+
+        def template_field(templates)
+          { type: FieldType::ENUM, label: 'Template', is_required: true,
+            enum_values: [NO_TEMPLATE] + templates.map { |t| t[:title] },
+            default_value: NO_TEMPLATE,
+            description: 'Pick a template to pre-fill the Message on the next page.' }
+        end
+
+        def subject_field(default_subject)
+          { type: FieldType::STRING, label: 'Subject', is_required: true,
+            default_value: template_default(default_subject, escape_html: false) }
+        end
+
+        def message_field(default_message, templates)
+          field = { type: FieldType::STRING, label: 'Message', widget: 'RichText', is_required: true,
+                    description: 'Sent as the ticket\'s first comment (HTML). Public comments trigger the ' \
+                                 'default Zendesk notification email to the requester.' }
+          return field.merge(default_value: template_default(default_message, escape_html: true)) if templates.empty?
+
+          # `value:` (not `default_value:`) — drop_default runs once (data
+          # key sticks after the first render); drop_deferred re-evaluates
+          # on every fetch, so Template changes re-fire the message proc.
+          field.merge(value: message_value(templates))
+        end
+
+        def priority_field
+          { type: FieldType::ENUM, label: 'Priority',
+            enum_values: TicketEnums::PRIORITY, default_value: 'normal' }
+        end
+
+        def type_field
+          { type: FieldType::ENUM, label: 'Type', enum_values: TicketEnums::TYPE }
+        end
+
+        def internal_note_field
+          { type: FieldType::BOOLEAN, label: 'Send as internal note',
+            description: 'When checked, the first comment is private and no email is sent to the requester.',
+            default_value: false }
+        end
+
+        def requester_default(value)
+          return nil if value.nil?
+          return template_default(value, escape_html: false) if value.is_a?(String)
+
+          lambda do |context|
+            record = fetch_record(context)
+            record.empty? ? nil : value.call(record)
+          rescue StandardError => e
+            ForestAdminDatasourceZendesk.logger.warn(
+              "[forest_admin_datasource_zendesk] requester_email_default resolver raised: #{e.class}: #{e.message}"
+            )
+            nil
+          end
+        end
+
+        def template_default(template, escape_html:)
+          return nil unless present?(template)
+          return template unless template.match?(TOKEN_RE)
+
+          ->(context) { interpolate(template, fetch_record(context), escape_html: escape_html) }
+        end
+
+        # Returns nil unless Template was just changed, so set_watch_changes
+        # carries over the user's current Message edits between renders.
+        def message_value(templates)
+          by_title = templates.to_h { |t| [t[:title], t[:content].to_s] }
+          lambda do |context|
+            return nil unless context.field_changed?('Template')
+
+            title = context.get_form_value('Template')
+            return '' if title == NO_TEMPLATE
+
+            content = by_title[title].to_s
+            return content unless content.match?(TOKEN_RE)
+
+            interpolate(content, fetch_record(context), escape_html: true)
+          end
+        end
+
+        def fetch_record(context)
+          context.get_record([]) || {}
+        rescue StandardError => e
+          ForestAdminDatasourceZendesk.logger.warn(
+            "[forest_admin_datasource_zendesk] failed to fetch record for token interpolation: #{e.class}: #{e.message}"
+          )
+          {}
+        end
+
+        # Message ships as html_body — unescaped `<` or `&` from a record
+        # value would break the outbound email or smuggle markup into it.
+        def interpolate(template, record, escape_html:)
+          template.gsub(TOKEN_RE) do
+            key = ::Regexp.last_match(1)
+            value = record[key]
+            next '' if value.nil?
+
+            escape_html ? CGI.escapeHTML(value.to_s) : value.to_s
+          end
+        end
+
+        def present?(value)
+          !value.nil? && value.to_s != ''
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_zendesk/plugins/create_ticket_with_notification.rb

@@ -0,0 +1,103 @@
+module ForestAdminDatasourceZendesk
+  module Plugins
+    # Zendesk creates the requester user on the fly from the form's email,
+    # so the action can be registered on any host collection — no relation
+    # to Zendesk needed.
+    class CreateTicketWithNotification < ForestAdminDatasourceCustomizer::Plugins::Plugin
+      BaseAction      = ForestAdminDatasourceCustomizer::Decorators::Action::BaseAction
+      ActionScope     = ForestAdminDatasourceCustomizer::Decorators::Action::Types::ActionScope
+      ForestException = ForestAdminDatasourceToolkit::Exceptions::ForestException
+
+      NAME = 'Create ticket and notify'.freeze
+
+      def run(_datasource_customizer, collection_customizer = nil, options = {})
+        datasource = options[:datasource]
+        raise ForestException, 'CreateTicketWithNotification plugin requires :datasource' unless datasource
+        raise ForestException, 'CreateTicketWithNotification plugin requires a collection' unless collection_customizer
+
+        opts = options.except(:datasource)
+        opts[:email_templates] = Array(opts[:email_templates]).compact
+        collection_customizer.add_action(opts[:action_name] || NAME, build_action(datasource, opts))
+      end
+
+      private
+
+      def build_action(datasource, opts)
+        BaseAction.new(scope: ActionScope::SINGLE, form: FormBuilder.build(opts), &executor(datasource, opts))
+      end
+
+      def executor(datasource, opts)
+        lambda do |context, result_builder|
+          values = context.form_values
+          email  = values['Requester email']
+          next result_builder.error(message: 'Requester email is required.') unless present?(email)
+
+          payload = build_payload(values, email, opts)
+          ticket_id = datasource.client.create_ticket(payload)['id']
+
+          writeback = write_back_ticket_id(context, opts[:ticket_id_field], ticket_id)
+          result_builder.success(message: success_message(ticket_id, values, writeback))
+        end
+      end
+
+      def build_payload(values, email, opts)
+        internal_note = truthy?(values['Send as internal note'])
+        payload = {
+          # Zendesk's create-user-on-the-fly requires a non-empty `name`;
+          # derive from the email's local-part. Ignored if the user exists.
+          'requester' => { 'email' => email, 'name' => derive_requester_name(email) },
+          'subject' => values['Subject'],
+          'comment' => { 'html_body' => values['Message'], 'public' => !internal_note }
+        }
+        priority = present?(opts[:priority_override]) ? opts[:priority_override] : values['Priority']
+        type     = present?(opts[:type_override])     ? opts[:type_override]     : values['Type']
+        payload['priority']  = priority             if present?(priority)
+        payload['type']      = type                 if present?(type)
+        # Zendesk's `recipient` = the support address replies come FROM.
+        payload['recipient'] = opts[:sender_email] if present?(opts[:sender_email])
+        payload
+      end
+
+      def derive_requester_name(email)
+        local = email.to_s.split('@').first.to_s
+        local.empty? ? email.to_s : local
+      end
+
+      # Best-effort: a writeback failure mustn't roll back the Zendesk ticket.
+      def write_back_ticket_id(context, field, ticket_id)
+        return :skipped if field.nil?
+
+        context.collection.update(context.filter, { field => ticket_id })
+        :ok
+      rescue StandardError => e
+        ForestAdminDatasourceZendesk.logger.warn(
+          "[forest_admin_datasource_zendesk] failed to store ticket id in '#{field}': #{e.class}: #{e.message}"
+        )
+        [:failed, "#{e.class}: #{e.message}"]
+      end
+
+      def success_message(ticket_id, values, writeback = :skipped)
+        base = base_success_message(ticket_id, values)
+        return base unless writeback.is_a?(Array) && writeback.first == :failed
+
+        "#{base} (warning: could not store the ticket id on the record: #{writeback.last})"
+      end
+
+      def base_success_message(ticket_id, values)
+        if truthy?(values['Send as internal note'])
+          "Ticket ##{ticket_id} created (internal note, no email)."
+        else
+          "Ticket ##{ticket_id} created and requester notified."
+        end
+      end
+
+      def truthy?(value)
+        value == true || value.to_s.casecmp('true').zero?
+      end
+
+      def present?(value)
+        !value.nil? && value.to_s != ''
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_zendesk/ticket_enums.rb

@@ -0,0 +1,8 @@
+module ForestAdminDatasourceZendesk
+  # Shared between the Ticket schema and plugins that build ticket forms.
+  module TicketEnums
+    STATUS   = %w[new open pending hold solved closed].freeze
+    PRIORITY = %w[low normal high urgent].freeze
+    TYPE     = %w[problem incident question task].freeze
+  end
+end

data/lib/forest_admin_datasource_zendesk/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceZendesk
-  VERSION = "1.29.2"
+  VERSION = "1.30.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_zendesk
 version: !ruby/object:Gem::Version
-  version: 1.29.2
+  version: 1.30.1
 platform: ruby
 authors:
 - Forest Admin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -78,8 +78,14 @@ files:
 - lib/forest_admin_datasource_zendesk/collections/user.rb
 - lib/forest_admin_datasource_zendesk/configuration.rb
 - lib/forest_admin_datasource_zendesk/datasource.rb
+- lib/forest_admin_datasource_zendesk/plugins/close_ticket.rb
+- lib/forest_admin_datasource_zendesk/plugins/close_ticket/errors.rb
+- lib/forest_admin_datasource_zendesk/plugins/close_ticket/messages.rb
+- lib/forest_admin_datasource_zendesk/plugins/create_ticket_with_notification.rb
+- lib/forest_admin_datasource_zendesk/plugins/create_ticket_with_notification/form_builder.rb
 - lib/forest_admin_datasource_zendesk/query/condition_tree_translator.rb
 - lib/forest_admin_datasource_zendesk/schema/custom_fields_introspector.rb
+- lib/forest_admin_datasource_zendesk/ticket_enums.rb
 - lib/forest_admin_datasource_zendesk/version.rb
 homepage: https://www.forestadmin.com
 licenses: