shopify-cli 2.7.3 → 2.10.0

data/lib/shopify_cli/method_object.rb

@@ -66,15 +66,27 @@ module ShopifyCLI
       # initializer or to `call`. If the keyword argument matches the name of
       # property, it is forwarded to the initializer, otherwise to call.
       #
-      def call(*args, **kwargs, &block)
-        properties.keys.yield_self do |properties|
-          instance = new(**kwargs.slice(*properties))
-          kwargs = kwargs.slice(*(kwargs.keys - properties))
-          if kwargs.any?
-            instance.call(*args, **kwargs, &block)
-          else
-            instance.call(*args, &block)
-          end
+      ruby2_keywords def call(*args, &block)
+        # This is an extremely complicated case of delegation. The method wants
+        # to delegate arguments, but to have control over which keyword
+        # arguments are delegated. I'm not sure the forward and backward
+        # compatibility of this unusual form of delegation has really been
+        # explored or there's any good way to support it. So I have done
+        # done something hacky here and I'm looking at the last argument and
+        # modifying the package of arguments to be delegated in-place.
+        if args.last.is_a?(Hash)
+          kwargs = args.last
+
+          initializer_kwargs = kwargs.slice(*properties.keys)
+          instance = new(**initializer_kwargs)
+
+          kwargs.reject! { |key| initializer_kwargs.key?(key) }
+          args.pop if kwargs.empty?
+          instance.call(*args, &block)
+        else
+          # Since the former is so complicated - let's have a fast path that
+          # is much simpler.
+          new.call(*args, &block)
         end
       end
 

data/lib/shopify_cli/partners_api/app_extensions/job.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "shopify_cli/thread_pool/job"
+
+module ShopifyCLI
+  class PartnersAPI
+    class AppExtensions
+      class Job < ShopifyCLI::ThreadPool::Job
+        attr_reader :result
+
+        def initialize(ctx, app, type)
+          super()
+          @ctx = ctx
+          @app = app
+          @api_key = @app["apiKey"]
+          @type = type
+        end
+
+        def perform!
+          resp = PartnersAPI.query(@ctx, "get_extension_registrations", **params)
+          @result = resp&.dig("data", "app") || {}
+        end
+
+        def patch_app_with_extensions!
+          @app.merge!(result)
+        end
+
+        private
+
+        def params
+          { api_key: @api_key, type: @type }
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/partners_api/app_extensions.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "shopify_cli/thread_pool"
+
+require_relative "app_extensions/job"
+
+module ShopifyCLI
+  class PartnersAPI
+    class AppExtensions
+      class << self
+        def fetch_apps_extensions(ctx, orgs, type)
+          jobs = apps(orgs).map { |app| AppExtensions::Job.new(ctx, app, type) }
+
+          consume_jobs!(jobs)
+          patch_apps_with_extensions!(jobs)
+
+          orgs
+        end
+
+        private
+
+        def apps(orgs)
+          orgs.flat_map { |org| org["apps"] }
+        end
+
+        def consume_jobs!(jobs)
+          thread_pool = ShopifyCLI::ThreadPool.new
+          jobs.each do |job|
+            thread_pool.schedule(job)
+          end
+          thread_pool.shutdown
+
+          raise_if_any_error(jobs)
+        end
+
+        def patch_apps_with_extensions!(jobs)
+          jobs.each(&:patch_app_with_extensions!)
+        end
+
+        def raise_if_any_error(jobs)
+          jobs.find(&:error?).tap { |job| raise job.error if job }
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/partners_api/organizations.rb

@@ -28,11 +28,8 @@ module ShopifyCLI
         end
 
         def fetch_with_extensions(ctx, type)
-          resp = PartnersAPI.query(ctx, "all_orgs_with_extensions", type: type)
-          (resp&.dig("data", "organizations", "nodes") || []).map do |org|
-            org["apps"] = (org.dig("apps", "nodes") || [])
-            org
-          end
+          orgs = fetch_with_app(ctx)
+          AppExtensions.fetch_apps_extensions(ctx, orgs, type)
         end
       end
     end

data/lib/shopify_cli/partners_api.rb

@@ -7,6 +7,7 @@ module ShopifyCLI
   #
   class PartnersAPI < API
     autoload :Organizations, "shopify_cli/partners_api/organizations"
+    autoload :AppExtensions, "shopify_cli/partners_api/app_extensions"
 
     class << self
       ##

data/lib/shopify_cli/project.rb

@@ -107,13 +107,6 @@ module ShopifyCLI
         @dir = nil
       end
 
-      private
-
-      def directory(dir)
-        @dir ||= Hash.new { |h, k| h[k] = __directory(k) }
-        @dir[dir]
-      end
-
       def at(dir)
         proj_dir = directory(dir)
         unless proj_dir
@@ -123,6 +116,13 @@ module ShopifyCLI
         @at[proj_dir]
       end
 
+      private
+
+      def directory(dir)
+        @dir ||= Hash.new { |h, k| h[k] = __directory(k) }
+        @dir[dir]
+      end
+
       def __directory(curr)
         loop do
           return nil if curr == "/" || /^[A-Z]:\/$/.match?(curr)
@@ -134,6 +134,7 @@ module ShopifyCLI
     end
 
     property :directory # :nodoc:
+    property :env # :nodoc:
 
     ##
     # will read, parse and return the envfile for the project

data/lib/shopify_cli/resources/env_file.rb

@@ -14,13 +14,21 @@ module ShopifyCLI
       }
 
       class << self
-        def read(_directory = Dir.pwd)
-          input = parse_external_env
+        def path(directory)
+          File.join(directory, FILENAME)
+        end
+
+        def read(_directory = Dir.pwd, overrides: {})
+          input = parse_external_env(overrides: overrides)
           new(input)
         end
 
+        def from_hash(hash)
+          new(env_input(hash))
+        end
+
         def parse(directory)
-          File.read(File.join(directory, FILENAME))
+          File.read(path(directory))
             .gsub("\r\n", "\n").split("\n").each_with_object({}) do |line, output|
             match = /\A([A-Za-z_0-9]+)\s*=\s*(.*)\z/.match(line)
             if match
@@ -37,10 +45,14 @@ module ShopifyCLI
           end
         end
 
-        def parse_external_env(directory = Dir.pwd)
+        def parse_external_env(directory = Dir.pwd, overrides: {})
+          env_input(parse(directory), overrides: overrides)
+        end
+
+        def env_input(parsed_source, overrides: {})
           env_details = {}
           extra = {}
-          parse(directory).each do |key, value|
+          parsed_source.merge(overrides).each do |key, value|
             if KEY_MAP[key]
               env_details[KEY_MAP[key]] = value
             else
@@ -53,7 +65,7 @@ module ShopifyCLI
       end
 
       property :api_key, required: true
-      property :secret, required: true
+      property :secret
       property :shop
       property :scopes
       property :host

data/lib/shopify_cli/result.rb

@@ -363,70 +363,72 @@ module ShopifyCLI
       Result::Failure.new(error)
     end
 
-    ##
-    # takes either a value or a block and chooses the appropriate result
-    # container based on the type of the value or the type of the block's return
-    # value. If the type is an exception, it is wrapped in a
-    # `ShopifyCLI::Result::Failure` and otherwise in a
-    # `ShopifyCLI::Result::Success`. If a block was provided instead of value, a
-    # `Proc` is returned and the result wrapping doesn't occur until the block
-    # is invoked.
-    #
-    # #### Parameters
-    #
-    # * `*args` should be an `Array` with zero or one element
-    # * `&block` should be a `Proc` that takes zero or one argument
-    #
-    # #### Returns
-    #
-    # Returns either a `Result::Success`, `Result::Failure` or a `Proc` that
-    # produces one of the former when invoked.
-    #
-    # #### Examples
-    #
-    #   Result.wrap(1) # => ShopifyCLI::Result::Success
-    #   Result.wrap(RuntimeError.new) # => ShopifyCLI::Result::Failure
-    #
-    #   Result.wrap { 1 } # => Proc
-    #   Result.wrap { 1 }.call # => ShopifyCLI::Result::Success
-    #   Result.wrap { raise }.call # => ShopifyCLI::Result::Failure
-    #
-    #   Result.wrap { |s| s.upcase }.call("hello").tap do |result|
-    #     result # => Result::Success
-    #     result.value # => "HELLO"
-    #   end
-    #
-    def self.wrap(*values, &block)
-      raise ArgumentError, "expected either a value or a block" unless (values.length == 1) ^ block
+    class << self
+      ##
+      # takes either a value or a block and chooses the appropriate result
+      # container based on the type of the value or the type of the block's return
+      # value. If the type is an exception, it is wrapped in a
+      # `ShopifyCli::Result::Failure` and otherwise in a
+      # `ShopifyCli::Result::Success`. If a block was provided instead of value, a
+      # `Proc` is returned and the result wrapping doesn't occur until the block
+      # is invoked.
+      #
+      # #### Parameters
+      #
+      # * `*args` should be an `Array` with zero or one element
+      # * `&block` should be a `Proc` that takes zero or one argument
+      #
+      # #### Returns
+      #
+      # Returns either a `Result::Success`, `Result::Failure` or a `Proc` that
+      # produces one of the former when invoked.
+      #
+      # #### Examples
+      #
+      #   Result.wrap(1) # => ShopifyCli::Result::Success
+      #   Result.wrap(RuntimeError.new) # => ShopifyCli::Result::Failure
+      #
+      #   Result.wrap { 1 } # => Proc
+      #   Result.wrap { 1 }.call # => ShopifyCli::Result::Success
+      #   Result.wrap { raise }.call # => ShopifyCli::Result::Failure
+      #
+      #   Result.wrap { |s| s.upcase }.call("hello").tap do |result|
+      #     result # => Result::Success
+      #     result.value # => "HELLO"
+      #   end
+      #
+      ruby2_keywords def wrap(*values, &block)
+        raise ArgumentError, "expected either a value or a block" unless (values.length == 1) ^ block
 
-      if values.length == 1
-        values.pop.yield_self do |value|
-          case value
-          when Result::Success, Result::Failure
-            value
-          when NilClass, Exception
-            Result.failure(value)
-          else
-            Result.success(value)
-          end
-        end
-      else
-        ->(*args) do
-          begin
-            wrap(block.call(*args))
-          rescue Exception => error # rubocop:disable Lint/RescueException
-            wrap(error)
+        if values.length == 1
+          values.pop.yield_self do |value|
+            case value
+            when Result::Success, Result::Failure
+              value
+            when NilClass, Exception
+              Result.failure(value)
+            else
+              Result.success(value)
+            end
           end
+        else
+          ->(*args) do
+            begin
+              wrap(block.call(*args))
+            rescue Exception => error # rubocop:disable Lint/RescueException
+              wrap(error)
+            end
+          end.ruby2_keywords
         end
       end
-    end
 
-    ##
-    # Wraps the given block and invokes it with the passed arguments.
-    #
-    def self.call(*args, &block)
-      raise ArgumentError, "expected a block" unless block
-      wrap(&block).call(*args)
+      ##
+      # Wraps the given block and invokes it with the passed arguments.
+      #
+      ruby2_keywords def call(*args, &block)
+        raise ArgumentError, "expected a block" unless block
+        wrap(&block).call(*args)
+      end
     end
   end
 end

data/lib/shopify_cli/task.rb

@@ -2,9 +2,11 @@ require "shopify_cli"
 
 module ShopifyCLI
   class Task
-    def self.call(*args, **kwargs)
-      task = new
-      task.call(*args, **kwargs)
+    class << self
+      ruby2_keywords def call(*args)
+        task = new
+        task.call(*args)
+      end
     end
 
     private

data/lib/shopify_cli/theme/dev_server/cdn/cdn_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    module DevServer
+      module Cdn
+        module CdnHelper
+          def proxy_request(env, uri, theme)
+            response = Net::HTTP.start(uri.host, 443, use_ssl: true) do |http|
+              req_class = Net::HTTP.const_get(method(env))
+
+              req = req_class.new(uri)
+              req.initialize_http_header(req_headers(theme))
+              req.body_stream = req_body(env)
+
+              http.request(req)
+            end
+
+            [
+              response.code.to_s,
+              {
+                "Content-Type" => response.content_type,
+                "Content-Length" => response.content_length.to_s,
+              },
+              [response.body],
+            ]
+          end
+
+          private
+
+          def method(env)
+            env["REQUEST_METHOD"].capitalize
+          end
+
+          def req_body(env)
+            env["rack.input"]
+          end
+
+          def req_headers(theme)
+            {
+              "Referer" => "https://#{theme.shop}",
+              "Transfer-Encoding" => "chunked",
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "cdn/cdn_helper"
+require_relative "local_assets"
+
+module ShopifyCLI
+  module Theme
+    module DevServer
+      class CdnAssets
+        include Cdn::CdnHelper
+
+        ASSETS_PROXY_PATH = "/cdn_asset"
+        ASSETS_CDN = "//cdn.shopify.com"
+        ASSETS_CDN_REGEX = %r{(https?:)?#{ASSETS_CDN}}
+        ASSETS_SOURCE_MAP_REGEX = /\/[\/|\*]# sourceMappingURL\=(\/.*)/
+
+        def initialize(app, theme:)
+          @app = app
+          @theme = theme
+        end
+
+        def call(env)
+          path = env["PATH_INFO"]
+
+          # Serve assets from CDN
+          return serve_asset(env, path) if path.start_with?(ASSETS_PROXY_PATH)
+
+          # Proxy the request, and replace the URLs in the response
+          status, headers, body = @app.call(env)
+          body = replace_asset_urls(body)
+          [status, headers, body]
+        end
+
+        private
+
+        def serve_asset(env, path)
+          path = path.gsub(%r{^#{ASSETS_PROXY_PATH}}, "")
+          query = env["QUERY_STRING"]
+          uri = asset_cdn_uri(path, query)
+
+          status, headers, body = proxy_request(env, uri, @theme)
+
+          [status, headers, replace_source_map_url(body)]
+        end
+
+        def asset_cdn_uri(path, query)
+          uri = URI.join("https:#{ASSETS_CDN}", path)
+          uri.query = query.split("&").last
+          uri
+        end
+
+        def replace_asset_urls(body)
+          [body.join.gsub(ASSETS_CDN_REGEX, ASSETS_PROXY_PATH)]
+        end
+
+        def replace_source_map_url(body)
+          body_content = body.join
+          map_regex_match = body_content.match(ASSETS_SOURCE_MAP_REGEX)
+          return body if map_regex_match.nil?
+
+          map_url = map_regex_match[1]
+          return body if map_url.nil?
+
+          [body_content.gsub(map_url, "#{ASSETS_PROXY_PATH}#{map_url}")]
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "cdn/cdn_helper"
+
 module ShopifyCLI
   module Theme
     module DevServer
       class CdnFonts
+        include Cdn::CdnHelper
+
         FONTS_PATH = "/fonts"
         FONTS_CDN = "https://fonts.shopifycdn.com"
         FONTS_REGEX = %r{#{FONTS_CDN}}
@@ -17,7 +21,7 @@ module ShopifyCLI
           path = env["PATH_INFO"]
 
           # Serve from fonts CDN
-          return serve_font(env) if path.start_with?(FONTS_PATH)
+          return serve_font(env, path) if path.start_with?(FONTS_PATH)
 
           # Proxy the request, and replace the URLs in the response
           status, headers, body = @app.call(env)
@@ -27,35 +31,11 @@ module ShopifyCLI
 
         private
 
-        def serve_font(env)
-          parameters = %w(PATH_INFO QUERY_STRING REQUEST_METHOD rack.input)
-          path, query, method, body_stream = *env.slice(*parameters).values
-
+        def serve_font(env, path)
+          query = env["QUERY_STRING"]
           uri = fonts_cdn_uri(path, query)
 
-          response = Net::HTTP.start(uri.host, 443, use_ssl: true) do |http|
-            req_class = Net::HTTP.const_get(method.capitalize)
-            req = req_class.new(uri)
-            req.initialize_http_header(fonts_cdn_headers)
-            req.body_stream = body_stream
-            http.request(req)
-          end
-
-          [
-            response.code.to_s,
-            {
-              "Content-Type" => response.content_type,
-              "Content-Length" => response.content_length.to_s,
-            },
-            [response.body],
-          ]
-        end
-
-        def fonts_cdn_headers
-          {
-            "Referer" => "https://#{@theme.shop}",
-            "Transfer-Encoding" => "chunked",
-          }
+          proxy_request(env, uri, @theme)
         end
 
         def fonts_cdn_uri(path, query)

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

@@ -15,9 +15,23 @@
     eventSource.onerror = () => eventSource.close();
   }
 
-  connect();
+  function reloadMode() {
+    var namespace = window.__SHOPIFY_CLI_ENV__;
+    return namespace.mode;
+  }
+
+  function isFullPageReloadMode(){
+    return reloadMode() === "full-page";
+  }
+
+  function isReloadModeActive(){
+    return reloadMode() !== "off";
+  }
 
   function isRefreshRequired(files) {
+    if (isFullPageReloadMode()) {
+      return true;
+    }
     return files.some((file) => !isCssFile(file) && !isSectionFile(file));
   }
 
@@ -33,7 +47,20 @@
     }
   }
 
-  function refreshPage() {
+  function setHotReloadCookie(files) {
+    var date = new Date();
+
+    // Hot reload cookie expires in 3 seconds
+    date.setSeconds(date.getSeconds() + 3);
+    
+    var sections = files.join(',');
+    var expires = date.toUTCString();
+
+    document.cookie = `hot_reload_sections=${sections}; expires=${expires}; path=/`;
+  }
+
+  function refreshPage(files) {
+    setHotReloadCookie(files);
     console.log('[HotReload] Refreshing entire page');
     window.location.reload();
   }
@@ -43,7 +70,7 @@
     var modifiedFiles = data.modified;
 
     if (isRefreshRequired(modifiedFiles)) {
-      refreshPage();
+      refreshPage(modifiedFiles);
     } else {
       modifiedFiles.forEach(refreshFile);
     }
@@ -106,4 +133,8 @@
       }
     }
   }
+
+  if (isReloadModeActive()) {
+    connect();
+  }
 })();

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

@@ -4,10 +4,11 @@ module ShopifyCLI
   module Theme
     module DevServer
       class HotReload
-        def initialize(ctx, app, theme:, watcher:, ignore_filter: nil)
+        def initialize(ctx, app, theme:, watcher:, mode:, ignore_filter: nil)
           @ctx = ctx
           @app = app
           @theme = theme
+          @mode = mode
           @streams = SSE::Streams.new
           @watcher = watcher
           @watcher.add_observer(self, :notify_streams_of_file_change)
@@ -48,12 +49,27 @@ module ShopifyCLI
 
         def inject_hot_reload_javascript(body)
           hot_reload_js = ::File.read("#{__dir__}/hot-reload.js")
-          hot_reload_script = "<script>\n#{hot_reload_js}</script>"
+          hot_reload_script = [
+            "<script>",
+            params_js,
+            hot_reload_js,
+            "</script>",
+          ].join("\n")
+
           body = body.join.gsub("</body>", "#{hot_reload_script}\n</body>")
 
           [body]
         end
 
+        def params_js
+          env = { mode: @mode }
+          <<~JS
+            (() => {
+              window.__SHOPIFY_CLI_ENV__ = #{env.to_json};
+            })();
+          JS
+        end
+
         def create_stream
           stream = @streams.new
 

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

@@ -11,6 +11,10 @@ module ShopifyCLI
             @path = path
           end
 
+          def join
+            @path.read
+          end
+
           # Naive implementation. Only used in unit tests.
           def each
             yield @path.read