rollout-ui 0.9.3 → 0.10.1

data/lib/rollout/ui/views/features/show.erb

@@ -6,8 +6,9 @@
 <h2 class="font-semibold text-xl text-gray-500 pt-12"><%= h(@feature.name) %></h2>
 
 <div class="w-8 h-1 bg-gray-300 my-10"></div>
-<main class="p-6 bg-gray-100 max-w-lg w-full text-sm rounded-sm">
+<main class="p-6 bg-gray-100 max-w-3xl w-full text-sm rounded-sm">
   <form id="updateFormSubmit" action="<%= h(feature_path(@feature.name)) %>" method="POST">
+    <input type="hidden" name="feature_version" value="<%= h(feature_version(@feature)) %>">
     <input type="hidden" name="last_updated_at" value="<%= h(@feature.data['updated_at']) %>">
     <div class="mb-5">
       <label class="block text-gray-500 mb-2" for="description">Description</label>
@@ -29,14 +30,7 @@
       <input class="appearance-none border rounded-sm w-full py-2 px-4 text-gray-600 leading-relaxed bg-white hover:border-gray-500" name="percentage" id="percentage" value="<%= h(@feature.percentage) %>" type="number" step="0.1">
     </div>
 
-    <div class="mb-5">
-      <label class="block text-gray-500 mb-2">Users</label>
-      <% if @feature.users.count > 150 %>
-        <div class="appearance-none border rounded-sm w-full py-2 px-4 text-gray-600 leading-relaxed bg-gray-100"><%= h(@feature.users.count) %></div>
-      <% else %>
-        <textarea class="appearance-none border rounded-sm w-full py-2 px-4 text-gray-600 leading-relaxed bg-white hover:border-gray-500" name="users" id="users" value="<%= h(@feature.users.join(', ')) %>" rows="2"><%= h(@feature.users.join(', ')) %></textarea>
-      <% end %>
-    </div>
+    <%= erb :"features/partials/enrolled_users", layout: false %>
   </form>
 
   <div class="flex items-center justify-end">
@@ -47,6 +41,4 @@
   </div>
 </main>
 
-<% history_events = @rollout.respond_to?(:logging) ? @rollout.logging.events(@feature.name).reverse : [] %>
-
-<%= erb :"features/partials/event_log", layout: false, locals: { events: history_events } %>
+<%= erb :"features/partials/event_log", layout: false, locals: { events: @history_events } %>

data/lib/rollout/ui/web.rb

@@ -14,7 +14,7 @@ module Rollout::UI
     NOT_FOUND = ->(env) { [404, { 'content-type' => 'text/plain', 'x-cascade' => 'pass' }, ['Not Found']] }
 
     def initialize
-      @static = Rack::Static.new(NOT_FOUND, urls: ['/css'], root: PUBLIC_PATH)
+      @static = Rack::Static.new(NOT_FOUND, urls: ['/css', '/js'], root: PUBLIC_PATH)
     end
 
     def call(env)
@@ -30,11 +30,23 @@ module Rollout::UI
     class Dispatcher
       include Helpers
 
+      class StaleFeature < StandardError
+      end
+
+      class InvalidEnrollment < StandardError
+      end
+
+      STALE_FEATURE_MESSAGE = 'This rollout changed since you opened it. Your update was not saved. Review the latest state and try again.'
+
       VIEWS_PATH = File.expand_path('views', __dir__)
       TEMPLATE_CACHE = {}
+      HISTORY_USER_LOOKUP_LIMIT = 150
 
       ROUTES = [
         [:GET, %r{\A/\z}, :index],
+        [:GET, %r{\A/users/search\z}, :search_users],
+        [:GET, %r{\A/features/(?<feature_name>[^/]+)/users/search\z}, :search_feature_users],
+        [:GET, %r{\A/features/(?<feature_name>[^/]+)/users\z}, :enrolled_users],
         [:GET, %r{\A/features/new\z}, :new_feature],
         [:POST, %r{\A/features/new\z}, :create_feature],
         [:POST, %r{\A/features/(?<feature_name>[^/]+)/activate-percentage\z}, :activate_percentage],
@@ -86,6 +98,8 @@ module Rollout::UI
             end
           )
         else
+          @history_events = @rollout.respond_to?(:logging) ? @rollout.logging.global_events.reverse : []
+          load_history_user_nicknames(@history_events)
           render_view(:'features/index')
         end
       end
@@ -99,37 +113,272 @@ module Rollout::UI
       end
 
       def show
+        response['cache-control'] = 'no-store'
         @rollout = config.get(:instance)
         @feature = @rollout.get(params[:feature_name])
 
         if json_request?
           json(feature_to_hash(@feature))
         else
+          load_selected_users
+          @history_events = @rollout.respond_to?(:logging) ? @rollout.logging.events(@feature.name).reverse : []
+          load_history_user_nicknames(@history_events)
           render_view(:'features/show')
         end
       end
 
+      def search_users
+        return not_found unless user_selector_enabled?
+
+        response['cache-control'] = 'no-store'
+        query = params[:q]
+        unless query.nil? || query.is_a?(String)
+          response.status = 400
+          return json(error: 'Nickname must be a string.')
+        end
+        query = query.to_s.strip
+        if query.length > USER_SEARCH_MAX_LENGTH
+          response.status = 400
+          return json(error: "Nickname must be at most #{USER_SEARCH_MAX_LENGTH} characters.")
+        end
+        return json(users: []) if query.length < user_search_min_length
+
+        begin
+          users = config.get(:user_search, query, user_search_limit)
+          json(users: users.take(user_search_limit).map { |user| user_to_hash(user) })
+        rescue StandardError
+          response.status = 503
+          json(error: 'Nickname search is temporarily unavailable. Please try again.')
+        end
+      end
+
+      def search_feature_users
+        return not_found unless user_selector_enabled?
+
+        response['cache-control'] = 'no-store'
+        @rollout = config.get(:instance)
+        begin
+          @feature = @rollout.get(params[:feature_name])
+        rescue StandardError
+          return not_found
+        end
+
+        query = params[:q]
+        unless query.nil? || query.is_a?(String)
+          response.status = 400
+          return json(error: 'Nickname must be a string.')
+        end
+        query = query.to_s.strip
+        if query.length > USER_SEARCH_MAX_LENGTH
+          response.status = 400
+          return json(error: "Nickname must be at most #{USER_SEARCH_MAX_LENGTH} characters.")
+        end
+        return json(users: [], feature_version: feature_version(@feature)) if query.length < user_search_min_length
+
+        enrolled_ids = @feature.users.map(&:to_s)
+        begin
+          users = config.get(:user_search, query, user_search_limit)
+          json(
+            users: users.take(user_search_limit).map do |user|
+              hashed = user_to_hash(user)
+              hashed.merge(enrolled: enrolled_ids.include?(hashed[:id]))
+            end,
+            feature_version: feature_version(@feature),
+          )
+        rescue StandardError
+          response.status = 503
+          json(error: 'Nickname search is temporarily unavailable. Please try again.')
+        end
+      end
+
+      def enrolled_users
+        response['cache-control'] = 'no-store'
+        @rollout ||= config.get(:instance)
+        begin
+          @feature = @rollout.get(params[:feature_name])
+        rescue StandardError
+          return not_found
+        end
+        load_selected_users
+
+        json(
+          users: @selected_users,
+          total: @users_total_count,
+          page: @user_page,
+          per_page: @users_per_page,
+          total_pages: @users_total_pages,
+          feature_version: feature_version(@feature),
+          lookup_failed: @selected_user_lookup_failed || false,
+        )
+      end
+
+      def load_selected_users
+        @users_per_page = USER_PAGE_SIZE
+        all_ids = @feature.users.map { |id| id.to_s }.uniq.sort
+        @users_total_count = all_ids.size
+        @users_total_pages = [ (all_ids.size.to_f / @users_per_page).ceil, 1 ].max
+        @user_page = parse_users_page(params[:page], @users_total_pages)
+        offset = (@user_page - 1) * @users_per_page
+        page_ids = all_ids[offset, @users_per_page] || []
+        if config.defined?(:user_lookup)
+          lookup_user_nicknames(page_ids)
+        end
+        @selected_users = page_ids.map { |id| { id: id, nickname: user_label(id, include_id: false) } }
+        @selected_user_lookup_failed = @user_lookup_failed == true
+      end
+
+      def parse_users_page(value, total_pages)
+        candidate = 1
+        unless value.is_a?(Array) || value.is_a?(Hash)
+          raw = value.to_s.strip
+          candidate = raw.to_i if raw.match?(/\A\d+\z/)
+        end
+        candidate = 1 if candidate < 1
+        candidate = total_pages if candidate > total_pages
+        candidate = 1 if candidate < 1
+        candidate
+      end
+
+      def load_history_user_nicknames(events)
+        return unless config.defined?(:user_lookup)
+
+        ids = {}
+        events.each do |event|
+          next unless event.name.to_s == 'update'
+
+          [:before, :after].each do |side|
+            changes = event.data.fetch(side)
+            Array(changes[:users] || changes['users']).each do |id|
+              id = id.to_s
+              next if @user_lookup_attempted&.key?(id)
+
+              ids[id] = true
+              return lookup_user_nicknames(ids.keys) if ids.size >= HISTORY_USER_LOOKUP_LIMIT
+            end
+          end
+        end
+        lookup_user_nicknames(ids.keys)
+      end
+
+      def lookup_user_nicknames(ids)
+        return unless config.defined?(:user_lookup)
+
+        @user_nicknames ||= {}
+        @user_lookup_attempted ||= {}
+        missing_ids = ids.uniq.reject { |id| @user_lookup_attempted.key?(id) }
+        return if missing_ids.empty?
+
+        missing_ids.each { |id| @user_lookup_attempted[id] = true }
+        config.get(:user_lookup, missing_ids).each do |user|
+          user = user_to_hash(user)
+          @user_nicknames[user[:id]] = user[:nickname]
+        end
+      rescue StandardError
+        @user_lookup_failed = true
+      end
+
+      def user_to_hash(user)
+        # Only expose the fields needed by the selector, even if a callback
+        # returns additional application-specific attributes.
+        id = user[:id] || user['id']
+        nickname = user[:nickname] || user['nickname']
+        raise ArgumentError, 'Users must have an id and nickname' if id.nil? || nickname.to_s.empty?
+
+        { id: id.to_s, nickname: nickname.to_s }
+      end
+
       def update
+        enrollment = parse_enrollment!
         rollout = config.get(:instance)
         actor = config.get(:actor, scope: self)
-        feature_data = rollout.get(params[:feature_name]).data
-        if feature_data['updated_at'] && params[:last_updated_at].to_s != feature_data['updated_at'].to_s
-          return redirect_to("#{feature_path(params[:feature_name])}?error=Rollout version outdated. Review changes below and try again.")
-        end
 
         with_rollout_context(rollout, actor: actor) do
           rollout.with_feature(params[:feature_name]) do |feature|
+            validate_feature_version!(feature, enrollment)
             feature.percentage = params[:percentage].to_f.clamp(0.0, 100.0)
             feature.groups = (params[:groups] || []).reject(&:empty?).map(&:to_sym)
-            if params[:users]
-              feature.users = params[:users].split(',').map(&:strip).uniq.sort
-            end
+            apply_enrollment!(feature, enrollment)
             feature.data["description"] = params[:description]
             feature.data["updated_at"] = Time.now.to_i
           end
         end
 
-        redirect_to feature_path(params[:feature_name])
+        redirect_location = feature_path(params[:feature_name])
+        if params.key?(:page)
+          after_feature = config.get(:instance).get(params[:feature_name])
+          total_pages = [ (after_feature.users.map(&:to_s).uniq.size.to_f / USER_PAGE_SIZE).ceil, 1 ].max
+          page = parse_users_page(params[:page], total_pages)
+          redirect_location = "#{feature_path(params[:feature_name])}?#{Rack::Utils.build_query('page' => page)}"
+        end
+        redirect_to redirect_location
+      rescue StaleFeature => error
+        query = Rack::Utils.build_query(error: error.message)
+        redirect_to("#{feature_path(params[:feature_name])}?#{query}")
+      rescue InvalidEnrollment
+        bad_request(StandardError.new('invalid enrollment update'))
+      end
+
+      # Delta mode is only the scalar marker "1" plus a real fingerprint.
+      # Any other present marker is rejected so it cannot fall through to a
+      # legacy full-list replacement. Legacy replacement runs only when the
+      # marker is absent, and only for a scalar string.
+      def parse_enrollment!
+        if params.key?(:user_changes)
+          raise InvalidEnrollment unless params[:user_changes] == '1'
+          raise InvalidEnrollment unless params[:feature_version].is_a?(String) && !params[:feature_version].empty?
+          additions = parse_delta_ids(params[:users_to_add])
+          removals = parse_delta_ids(params[:users_to_remove])
+          raise InvalidEnrollment if additions.nil? || removals.nil?
+          return [:delta, additions, removals]
+        end
+
+        return nil unless params.key?(:users)
+
+        users = params[:users]
+        return nil if users.nil?
+        raise InvalidEnrollment unless users.is_a?(String)
+        [:legacy, users]
+      end
+
+      def apply_enrollment!(feature, enrollment)
+        return if enrollment.nil?
+
+        kind, *payload = enrollment
+        if kind == :delta
+          additions, removals = payload
+          current = feature.users.map { |id| id.to_s }.uniq
+          feature.users = (current + additions - removals).uniq.sort
+        else
+          feature.users = payload.fetch(0).split(',').map(&:strip).reject(&:empty?).uniq.sort
+        end
+      end
+
+      def parse_delta_ids(value)
+        return [] if value.nil?
+        return nil unless value.is_a?(String) || value.is_a?(Array)
+        list = value.is_a?(Array) ? value : value.to_s.split(',')
+        return nil unless list.all? { |entry| entry.is_a?(String) }
+        list.map(&:strip).reject(&:empty?)
+      rescue StandardError
+        nil
+      end
+
+      def validate_feature_version!(feature, enrollment = nil)
+        if enrollment&.first == :delta
+          version = params[:feature_version]
+          raise InvalidEnrollment unless version.is_a?(String) && !version.empty?
+          if version != feature_version(feature)
+            raise StaleFeature, STALE_FEATURE_MESSAGE
+          end
+          return
+        end
+
+        stale = if params.key?(:feature_version)
+          params[:feature_version].to_s != feature_version(feature)
+        else
+          feature.data['updated_at'] && params[:last_updated_at].to_s != feature.data['updated_at'].to_s
+        end
+        raise StaleFeature, STALE_FEATURE_MESSAGE if stale
       end
 
       def activate_percentage

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rollout-ui
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.10.1
 platform: ruby
 authors:
 - FetLife
@@ -227,11 +227,17 @@ files:
 - lib/rollout/ui.rb
 - lib/rollout/ui/config.rb
 - lib/rollout/ui/helpers.rb
+- lib/rollout/ui/public/css/enrolled-users.css
 - lib/rollout/ui/public/css/tailwind.min.css
+- lib/rollout/ui/public/js/enrolled-users.js
+- lib/rollout/ui/public/js/user-selector.js
 - lib/rollout/ui/version.rb
 - lib/rollout/ui/views/features/index.erb
 - lib/rollout/ui/views/features/new.erb
+- lib/rollout/ui/views/features/partials/enrolled_users.erb
 - lib/rollout/ui/views/features/partials/event_log.erb
+- lib/rollout/ui/views/features/partials/user_pagination.erb
+- lib/rollout/ui/views/features/partials/user_selector.erb
 - lib/rollout/ui/views/features/show.erb
 - lib/rollout/ui/views/layout.erb
 - lib/rollout/ui/web.rb