shopify-cli 2.15.0 → 2.15.3

data/lib/shopify_cli/release.rb

@@ -0,0 +1,194 @@
+require "net/http"
+require "fileutils"
+require "shopify_cli/sed"
+require "shopify_cli/changelog"
+require "octokit"
+
+module ShopifyCLI
+  class Release
+    def initialize(new_version, github_access_token)
+      @new_version = new_version
+      @changelog = ShopifyCLI::Changelog.new
+      @github = Octokit::Client.new(access_token: github_access_token)
+    end
+
+    def prepare!
+      ensure_updated_main
+      create_release_branch
+      update_changelog
+      update_versions_in_files
+      commit_packaging
+      pr = create_pr
+      system("open #{pr["html_url"]}")
+    end
+
+    def package!
+      ensure_updated_main
+      ensure_correct_gem_version
+      Rake::Task["package"].invoke
+      update_homebrew
+      create_github_release
+    end
+
+    private
+
+    attr_reader :new_version, :changelog, :github
+
+    def ensure_updated_main
+      # We can't be sure what is the correct action to take if changes have been
+      # made but not committed. Ensure the user handles the situation before
+      # moving on.
+      unless %x(git status --porcelain).empty?
+        raise <<~MESSAGE
+          Uncommitted changes have been made to the repository.
+          Please make sure `git status` does not show any changes before continuing.
+        MESSAGE
+      end
+      system_or_fail("git checkout main", "check out main branch")
+      unless system("git pull")
+        raise "git pull failed, cannot be sure there aren't new commits!"
+      end
+    end
+
+    def create_release_branch
+      puts "Checking out release branch"
+      system_or_fail("git checkout -b #{release_branch_name}", "check out release branch")
+    end
+
+    def update_changelog
+      if release_notes("Unreleased").empty?
+        puts "No unreleased CHANGELOG updates found!"
+      else
+        puts "Updating CHANGELOG"
+        changelog.update_version!(new_version)
+      end
+    end
+
+    def update_versions_in_files
+      version_file = File.join(ShopifyCLI::ROOT, "lib/shopify_cli/version.rb")
+      puts "Updating version.rb"
+      ShopifyCLI::Sed.new.replace_inline(version_file, ShopifyCLI::VERSION, new_version)
+      gemfile_lock = File.join(ShopifyCLI::ROOT, "Gemfile.lock")
+      puts "Updating Gemfile.lock"
+      ShopifyCLI::Sed.new.replace_inline(
+        gemfile_lock,
+        "shopify-cli (#{ShopifyCLI::VERSION})",
+        "shopify-cli (#{new_version})",
+      )
+    end
+
+    def commit_packaging
+      puts "Committing"
+      system_or_fail("git commit -am 'Packaging for release v#{new_version}'", "commit")
+      system_or_fail("git push -u origin #{release_branch_name}", "push branch")
+    end
+
+    def create_pr
+      repo = "Shopify/shopify-cli"
+      github.create_pull_request(
+        repo,
+        "main",
+        release_branch_name,
+        "Packaging for release v#{new_version}",
+        release_notes(new_version)
+      ).tap { |results| puts "Created #{repo} PR ##{results["number"]}" }
+    end
+
+    def ensure_correct_gem_version
+      response = Net::HTTP.get(URI("https://rubygems.org/api/v1/versions/shopify-cli/latest.json"))
+      latest_version = JSON.parse(response)["version"]
+      unless latest_version == new_version
+        raise "Attempted to update to #{new_version}, but latest on RubyGems is #{latest_version}"
+      end
+    end
+
+    def update_homebrew
+      ensure_updated_homebrew_repo
+      update_homebrew_repo
+      pr = create_homebrew_pr
+      system("open #{pr["html_url"]}")
+    end
+
+    def ensure_updated_homebrew_repo
+      unless File.exist?(homebrew_path)
+        system_or_fail("/opt/dev/bin/dev clone homebrew-shopify", "clone homebrew-shopify repo")
+      end
+
+      Dir.chdir(homebrew_path) do
+        system_or_fail("git checkout master && git pull", "pull latest homebrew-shopify")
+        system_or_fail("git checkout -b #{homebrew_release_branch}", "check out homebrew branch")
+      end
+    end
+
+    def update_homebrew_repo
+      source_file = File.join(package_dir, "shopify-cli.rb")
+      FileUtils.copy(source_file, homebrew_path)
+      Dir.chdir(homebrew_path) do
+        system_or_fail("git commit -am '#{homebrew_update_message}'", "commit homebrew update")
+        system_or_fail("git push -u origin #{homebrew_release_branch}", "push homebrew branch")
+      end
+    end
+
+    def create_homebrew_pr
+      repo = "Shopify/homebrew-shopify"
+      github.create_pull_request(
+        repo,
+        "master",
+        homebrew_release_branch,
+        homebrew_update_message,
+        homebrew_release_notes
+      ).tap { |results| puts "Created #{repo} PR ##{results["number"]}" }
+    end
+
+    def create_github_release
+      release = github.create_release(
+        "Shopify/shopify-cli",
+        "v#{new_version}",
+        {
+          name: "Version #{new_version}",
+          body: release_notes(new_version),
+        }
+      )
+      %w(.deb -1.noarch.rpm).each do |suffix|
+        github.upload_asset(
+          release["url"],
+          File.join(package_dir, "shopify-cli-#{new_version}#{suffix}")
+        )
+      end
+      system("open #{release["html_url"]}")
+    end
+
+    def homebrew_path
+      @homebrew_path ||= %x(/opt/dev/bin/dev project-path homebrew-shopify).chomp
+    end
+
+    def homebrew_update_message
+      @homebrew_update_message ||= "Update Shopify CLI to #{new_version}"
+    end
+
+    def package_dir
+      @package_dir ||= File.join(ShopifyCLI::ROOT, "packaging", "builds", new_version)
+    end
+
+    def homebrew_release_branch
+      "release_#{new_version.split(".").join("_")}_of_shopify-cli"
+    end
+
+    def homebrew_release_notes
+      "I'm releasing a new version of the Shopify CLI, " \
+        "[#{new_version}](https://github.com/Shopify/shopify-cli/releases/tag/v#{new_version})"
+    end
+
+    def release_branch_name
+      @release_branch_name ||= "release_#{new_version.split(".").join("_")}"
+    end
+
+    def release_notes(version)
+      changelog.release_notes(version)
+    end
+
+    def system_or_fail(command, action)
+      raise "Failed to #{action}!" unless system(command)
+    end
+  end
+end

data/lib/shopify_cli/sed.rb

@@ -0,0 +1,19 @@
+module ShopifyCLI
+  class Sed
+    class SedError < StandardError; end
+
+    def replace_inline(filename, pattern, output)
+      command =
+        case CLI::Kit::System.os
+        when :mac
+          "sed -i ''"
+        when :linux
+          "sed -i"
+        else
+          raise "Unrecognized system!"
+        end
+      success = system("#{command} 's/#{pattern}/#{output}/' #{filename}")
+      raise SedError unless success
+    end
+  end
+end

data/lib/shopify_cli/services/app/create/rails_service.rb

@@ -108,8 +108,10 @@ module ShopifyCLI
           end
 
           def check_ruby
-            ruby_version = Environment.ruby_version(context)
-            return if ruby_version.satisfies?("~>2.5") || ruby_version.satisfies?("~>3.1.0")
+            ruby_version = Environment.ruby_version(context: context)
+            return if ruby_version.satisfies?("~>2.5") ||
+              ruby_version.satisfies?("~>3.0.0") ||
+              ruby_version.satisfies?("~>3.1.0")
             context.abort(context.message("core.app.create.rails.error.invalid_ruby_version"))
           end
 
@@ -205,6 +207,12 @@ module ShopifyCLI
           end
 
           def set_custom_ua
+            requires_ua_file = Dir.chdir(context.root) do
+              context.ruby_gem_version("shopify_app") < ::Semantic::Version.new("19.0.0")
+            end
+
+            return unless requires_ua_file
+
             ua_path = File.join("config", "initializers", "user_agent.rb")
             context.write(ua_path, USER_AGENT_CODE)
           end

data/lib/shopify_cli/services/app/serve/node_service.rb

@@ -2,32 +2,9 @@ module ShopifyCLI
   module Services
     module App
       module Serve
-        class NodeService < BaseService
-          attr_accessor :host, :port, :context
-
-          def initialize(host:, port:, context:)
-            @host = host
-            @port = port
-            @context = context
-            super()
-          end
-
+        class NodeService < ServeService
           def call
-            project = ShopifyCLI::Project.current
-            url = host || ShopifyCLI::Tunnel.start(context, port: port)
-            raise ShopifyCLI::Abort,
-              context.message("core.app.serve.error.host_must_be_https") if url.match(/^https/i).nil?
-            project.env.update(context, :host, url)
-            ShopifyCLI::Tasks::UpdateDashboardURLS.call(
-              context,
-              url: url,
-              callback_url: "/auth/callback",
-            )
-
-            if project.env.shop
-              project_url = "#{project.env.host}/auth?shop=#{project.env.shop}"
-              context.puts("\n" + context.message("core.app.serve.open_info", project_url) + "\n")
-            end
+            generate_url
 
             CLI::UI::Frame.open(context.message("core.app.serve.running_server")) do
               env = project.env.to_h

data/lib/shopify_cli/services/app/serve/php_service.rb

@@ -2,32 +2,9 @@ module ShopifyCLI
   module Services
     module App
       module Serve
-        class PHPService < BaseService
-          attr_accessor :host, :port, :context
-
-          def initialize(host:, port:, context:)
-            @host = host
-            @port = port
-            @context = context
-            super()
-          end
-
+        class PHPService < ServeService
           def call
-            project = ShopifyCLI::Project.current
-            url = host || ShopifyCLI::Tunnel.start(context, port: port)
-            raise ShopifyCLI::Abort,
-              context.message("core.app.serve.error.host_must_be_https") if url.match(/^https/i).nil?
-            project.env.update(context, :host, url)
-            ShopifyCLI::Tasks::UpdateDashboardURLS.call(
-              context,
-              url: url,
-              callback_url: "/auth/callback",
-            )
-
-            if project.env.shop
-              project_url = "#{project.env.host}/login?shop=#{project.env.shop}"
-              context.puts("\n" + context.message("core.app.serve.open_info", project_url) + "\n")
-            end
+            generate_url
 
             CLI::UI::Frame.open(context.message("core.app.serve.running_server")) do
               if ShopifyCLI::ProcessSupervision.running?(:npm_watch)

data/lib/shopify_cli/services/app/serve/rails_service.rb

@@ -2,38 +2,18 @@ module ShopifyCLI
   module Services
     module App
       module Serve
-        class RailsService < BaseService
-          attr_accessor :host, :port, :context
-
-          def initialize(host:, port:, context:)
-            @host = host
-            @port = port
-            @context = context
-            super()
-          end
-
+        class RailsService < ServeService
           def call
-            project = ShopifyCLI::Project.current
-            url = host || ShopifyCLI::Tunnel.start(context, port: port)
-            raise ShopifyCLI::Abort,
-              context.message("core.app.serve.error.host_must_be_https") if url.match(/^https/i).nil?
-            project.env.update(context, :host, url)
-            ShopifyCLI::Tasks::UpdateDashboardURLS.call(
-              context,
-              url: url,
-              callback_url: "/auth/shopify/callback",
-            )
-
-            if project.env.shop
-              project_url = "#{project.env.host}/login?shop=#{project.env.shop}"
-              context.puts("\n" + context.message("core.app.serve.open_info", project_url) + "\n")
-            end
+            generate_url
 
             CLI::UI::Frame.open(context.message("core.app.serve.running_server")) do
-              env = ShopifyCLI::Project.current.env.to_h
-              env.delete("HOST")
+              original_env = JSON.parse(ENV["ORIGINAL_ENV"] || "{}")
+              env = original_env.merge(ShopifyCLI::Project.current.env.to_h)
+              env.delete("HOST") if context.ruby_gem_version("shopify_app") < ::Semantic::Version.new("19.0.0")
               env["PORT"] = port.to_s
-              env["GEM_PATH"] = Rails::Gem.gem_path(context)
+              env["GEM_PATH"] =
+                [env["GEM_PATH"], Rails::Gem.gem_path(context)].compact
+                  .join(CLI::UI::OS.current.path_separator)
               if context.windows?
                 context.system("ruby bin\\rails server", env: env)
               else

data/lib/shopify_cli/services/app/serve/serve_service.rb

@@ -0,0 +1,57 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class ServeService < BaseService
+          attr_accessor :host, :port, :no_update, :context
+
+          def initialize(host:, port:, no_update:, context:)
+            @host = host
+            @port = port
+            @no_update = no_update
+            @context = context
+            super()
+          end
+
+          def call
+            raise NotImplementedError
+          end
+
+          private
+
+          def generate_url
+            create_tunnel
+            update_url unless no_update
+            show_app_url
+          end
+
+          def create_tunnel
+            url = host || ShopifyCLI::Tunnel.start(context, port: port)
+            raise ShopifyCLI::Abort,
+              context.message("core.app.serve.error.host_must_be_https") if url.match(/^https/i).nil?
+            project.env.update(context, :host, url)
+          end
+
+          def update_url
+            ShopifyCLI::Tasks::UpdateDashboardURLS.call(
+              context,
+              url: project.env.host,
+              callback_url: "/auth/shopify/callback",
+            )
+          end
+
+          def show_app_url
+            return unless project.env.shop
+
+            project_url = "#{project.env.host}/login?shop=#{project.env.shop}"
+            context.puts("\n" + context.message("core.app.serve.open_info", project_url) + "\n")
+          end
+
+          def project
+            @project ||= ShopifyCLI::Project.current
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/services.rb

@@ -5,6 +5,7 @@ module ShopifyCLI
 
     module App
       module Serve
+        autoload :ServeService, "shopify_cli/services/app/serve/serve_service"
         autoload :NodeService, "shopify_cli/services/app/serve/node_service"
         autoload :RailsService, "shopify_cli/services/app/serve/rails_service"
         autoload :PHPService, "shopify_cli/services/app/serve/php_service"

data/lib/shopify_cli/tasks/update_dashboard_urls.rb

@@ -9,24 +9,22 @@ module ShopifyCLI
         api_key = project.env.api_key
         result = ShopifyCLI::PartnersAPI.query(ctx, "get_app_urls", apiKey: api_key)
         app = result["data"]["app"]
-        consent = check_application_url(app["applicationUrl"], url)
+
+        return if app["applicationUrl"].match(url)
+
         constructed_urls = construct_redirect_urls(app["redirectUrlWhitelist"], url, callback_url)
-        return if url == app["applicationUrl"]
         ShopifyCLI::PartnersAPI.query(@ctx, "update_dashboard_urls", input: {
-          applicationUrl: consent ? url : app["applicationUrl"],
-          redirectUrlWhitelist: constructed_urls, apiKey: api_key
+          applicationUrl: url,
+          redirectUrlWhitelist: constructed_urls,
+          apiKey: api_key,
         })
+
         @ctx.puts(@ctx.message("core.tasks.update_dashboard_urls.updated"))
       rescue
         @ctx.puts(@ctx.message("core.tasks.update_dashboard_urls.update_error", ShopifyCLI::TOOL_NAME))
         raise
       end
 
-      def check_application_url(application_url, new_url)
-        return false if application_url.match(new_url)
-        CLI::UI::Prompt.confirm(@ctx.message("core.tasks.update_dashboard_urls.update_prompt"))
-      end
-
       def construct_redirect_urls(urls, new_url, callback_url)
         new_urls = urls.map do |url|
           if (match = url.match(NGROK_REGEX))

data/lib/shopify_cli/theme/dev_server/hot-reload.js

@@ -15,17 +15,37 @@
     eventSource.onerror = () => eventSource.close();
   }
 
+  function sectionNamesByType(type) {
+    const namespace = window.__SHOPIFY_CLI_ENV__;
+    return namespace.section_names_by_type[type] || [];
+  }
+
   function reloadMode() {
-    var namespace = window.__SHOPIFY_CLI_ENV__;
+    const namespace = window.__SHOPIFY_CLI_ENV__;
     return namespace.mode;
   }
 
+  function querySelectDOMSections(idSuffix) {
+    const elements = document.querySelectorAll(`[id^='shopify-section'][id$='${idSuffix}']`);
+    return Array.from(elements);
+  }
+
+  function fetchDOMSections(name) {
+    const domSections = sectionNamesByType(name).flatMap((n) => querySelectDOMSections(n));
+    
+    if (domSections.length > 0) {
+      return domSections;
+    }
+
+    return querySelectDOMSections(name);
+  }
+
   function isFullPageReloadMode(){
-    return reloadMode() === "full-page";
+    return reloadMode() === 'full-page';
   }
 
   function isReloadModeActive(){
-    return reloadMode() !== "off";
+    return reloadMode() !== 'off';
   }
 
   function isRefreshRequired(files) {
@@ -104,26 +124,28 @@
     constructor(filename) {
       this.filename = filename;
       this.name = filename.split('/').pop().replace('.liquid', '');
-      this.element = document.querySelector(`[id^='shopify-section'][id$='${this.name}']`);
+      this.elements = fetchDOMSections(this.name);
     }
 
     valid() {
-      return this.filename.startsWith('sections/') && this.element;
+      return this.filename.startsWith('sections/') && this.elements.length > 0;
     }
 
-    async refresh() {
-      var url = new URL(window.location.href);
-      url.searchParams.append('section_id', this.name);
+    async refreshElement(element) {
+
+      const sectionId = element.id.replace(/^shopify-section-/, '');
+      const url = new URL(window.location.href);
+
+      url.searchParams.append('section_id', sectionId);
+
+      const response = await fetch(url);
 
       try {
-        const response = await fetch(url);
         if (response.headers.get('x-templates-from-params') == '1') {
           const html = await response.text();
-          this.element.outerHTML = html;
-
-          console.log(`[HotReload] Reloaded ${this.name} section`);
+          element.outerHTML = html;
         } else {
-          window.location.reload()
+          window.location.reload();
 
           console.log(`[HotReload] Hot-reloading not supported, fully reloading ${this.name} section`);
         }
@@ -132,6 +154,11 @@
         console.log(`[HotReload] Failed to reload ${this.name} section: ${e.message}`);
       }
     }
+
+    async refresh() {
+      console.log(`[HotReload] Reloaded ${this.name} sections`);
+      this.elements.forEach(this.refreshElement);
+    }
   }
 
   if (isReloadModeActive()) {

data/lib/shopify_cli/theme/dev_server/hot_reload/remote_file_reloader.rb

@@ -51,7 +51,7 @@ module ShopifyCLI
           def fetch_asset(file)
             api_client.get(
               path: "themes/#{@theme.id}/assets.json",
-              query: URI.encode_www_form("asset[key]" => file.relative_path.to_s),
+              query: URI.encode_www_form("asset[key]" => file.relative_path),
             )
           rescue ShopifyCLI::API::APIRequestNotFoundError
             [404, {}]

data/lib/shopify_cli/theme/dev_server/hot_reload/sections_index.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    module DevServer
+      class HotReload
+        class SectionsIndex
+          def initialize(theme)
+            @theme = theme
+          end
+
+          def section_names_by_type
+            index = {}
+
+            files.each do |file|
+              section_hash(file).each do |key, value|
+                name = key
+                type = value&.dig("type")
+
+                next if !name || !type
+
+                index[type] = [] unless index[type]
+                index[type] << name
+              end
+            end
+
+            index
+          end
+
+          private
+
+          def section_hash(file)
+            content = JSON.parse(file.read)
+            return [] unless content.is_a?(Hash)
+
+            sections = content["sections"]
+            return [] if sections.nil?
+
+            sections
+          rescue JSON::JSONError
+            []
+          end
+
+          def files
+            @theme.json_files
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/dev_server/hot_reload.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "hot_reload/remote_file_reloader"
+require_relative "hot_reload/sections_index"
 
 module ShopifyCLI
   module Theme
@@ -13,6 +14,7 @@ module ShopifyCLI
           @mode = mode
           @streams = SSE::Streams.new
           @remote_file_reloader = RemoteFileReloader.new(ctx, theme: @theme, streams: @streams)
+          @sections_index = SectionsIndex.new(@theme)
           @watcher = watcher
           @watcher.add_observer(self, :notify_streams_of_file_change)
           @ignore_filter = ignore_filter
@@ -78,7 +80,10 @@ module ShopifyCLI
         end
 
         def params_js
-          env = { mode: @mode }
+          env = {
+            mode: @mode,
+            section_names_by_type: @sections_index.section_names_by_type,
+          }
           <<~JS
             (() => {
               window.__SHOPIFY_CLI_ENV__ = #{env.to_json};

data/lib/shopify_cli/theme/dev_server/local_assets.rb

@@ -71,7 +71,7 @@ module ShopifyCLI
 
         def replace_asset_urls(body)
           replaced_body = body.join.gsub(ASSET_REGEX) do |match|
-            path = Pathname.new(Regexp.last_match[1])
+            path = Regexp.last_match[1]
             if @theme.static_asset_paths.include?(path)
               "/#{path}"
             else

data/lib/shopify_cli/theme/dev_server/remote_watcher/json_files_update_job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "shopify_cli/thread_pool/job"
+
+module ShopifyCLI
+  module Theme
+    module DevServer
+      class RemoteWatcher
+        class JsonFilesUpdateJob < ShopifyCLI::ThreadPool::Job
+          def initialize(theme, syncer, interval)
+            super(interval)
+
+            @theme = theme
+            @syncer = syncer
+          end
+
+          def perform!
+            @syncer.fetch_checksums!
+            @syncer.enqueue_get(json_files)
+          end
+
+          private
+
+          def json_files
+            @theme
+              .json_files
+              .reject { |file| @syncer.pending_updates.include?(file) }
+              .reject { |file| @syncer.broken_file?(file) }
+              .reject { |file| @syncer.ignore_file?(file) }
+          end
+        end
+      end
+    end
+  end
+end