shopify-cli 2.9.0 → 2.10.0

data/lib/shopify_cli/commands/login.rb

@@ -15,6 +15,8 @@ module ShopifyCLI
 
       def call(*)
         shop = (options.flags[:shop] || @ctx.getenv("SHOPIFY_SHOP" || nil))
+        ShopifyCLI::DB.set(shop: self.class.validate_shop(shop, context: @ctx)) unless shop.nil?
+
         if shop.nil? && Shopifolk.check
           Shopifolk.reset
           @ctx.puts(@ctx.message("core.tasks.select_org_and_shop.identified_as_shopify"))
@@ -31,25 +33,17 @@ module ShopifyCLI
           IdentityAuth.new(ctx: @ctx).authenticate
           org = select_organization
           ShopifyCLI::DB.set(organization_id: org["id"].to_i) unless org.nil?
-
+          Whoami.call([], "whoami")
         end
-        # validate that shop belongs to organization
-        ShopifyCLI::DB.set(shop: self.class.validate_shop(shop: shop, org: org, context: @ctx)) unless shop.nil?
-        Whoami.call([], "whoami")
       end
 
       def self.help
         ShopifyCLI::Context.message("core.login.help", ShopifyCLI::TOOL_NAME)
       end
 
-      def self.validate_shop(shop:, org:, context:)
+      def self.validate_shop(shop, context:)
         permanent_domain = shop_to_permanent_domain(shop)
         context.abort(context.message("core.login.invalid_shop", shop)) unless permanent_domain
-        if org
-          stores_owned = org["stores"]
-          is_verified = stores_owned.any? { |store| store["shopDomain"] == permanent_domain }
-          context.abort(context.message("core.login.invalid_shop", shop)) unless is_verified
-        end
         permanent_domain
       end
 

data/lib/shopify_cli/constants.rb

@@ -36,12 +36,16 @@ module ShopifyCLI
       # the partners dashboard and identity.
       LOCAL_PARTNERS = "SHOPIFY_APP_CLI_LOCAL_PARTNERS"
 
-      # When true the CLI points to a spin instance of spin
-      SPIN_PARTNERS = "SHOPIFY_APP_CLI_SPIN_PARTNERS"
+      # When true the CLI points to spin instances of services
+      SPIN = "SPIN"
+      INFER_SPIN = "INFER_SPIN"
       SPIN_WORKSPACE = "SPIN_WORKSPACE"
       SPIN_NAMESPACE = "SPIN_NAMESPACE"
       SPIN_HOST = "SPIN_HOST"
 
+      # Deprecated, equivalent to using SPIN=1
+      SPIN_PARTNERS = "SHOPIFY_APP_CLI_SPIN_PARTNERS"
+
       # Environments
       TEST = "SHOPIFY_CLI_TEST"
       ACCEPTANCE_TEST = "SHOPIFY_CLI_ACCEPTANCE_TEST"

data/lib/shopify_cli/core/executor.rb

@@ -3,10 +3,10 @@ require "shopify_cli"
 module ShopifyCLI
   module Core
     class Executor < CLI::Kit::Executor
-      def initialize(ctx, task_registry, *args, **kwargs)
-        @ctx = ctx || ShopifyCLI::Context.new
-        @task_registry = task_registry || ShopifyCLI::Tasks::TaskRegistry.new
-        super(*args, **kwargs)
+      ruby2_keywords def initialize(ctx, task_registry, *args)
+        @ctx = ctx || ShopifyCli::Context.new
+        @task_registry = task_registry || ShopifyCli::Tasks::TaskRegistry.new
+        super(*args)
       end
 
       def call(command, command_name, args)

data/lib/shopify_cli/environment.rb

@@ -61,17 +61,10 @@ module ShopifyCLI
       )
     end
 
-    def self.use_spin_partners_instance?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::SPIN_PARTNERS,
-        env_variables: env_variables
-      )
-    end
-
     def self.partners_domain(env_variables: ENV)
       if use_local_partners_instance?(env_variables: env_variables)
         "partners.myshopify.io"
-      elsif use_spin_partners_instance?(env_variables: env_variables)
+      elsif use_spin?(env_variables: env_variables)
         "partners.#{spin_url(env_variables: env_variables)}"
       else
         "partners.shopify.com"
@@ -79,15 +72,31 @@ module ShopifyCLI
     end
 
     def self.use_spin?(env_variables: ENV)
-      !env_variables[Constants::EnvironmentVariables::SPIN_WORKSPACE].nil? &&
-        !env_variables[Constants::EnvironmentVariables::SPIN_NAMESPACE].nil?
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::SPIN,
+        env_variables: env_variables
+      ) || env_variable_truthy?(
+        Constants::EnvironmentVariables::SPIN_PARTNERS,
+        env_variables: env_variables
+      )
+    end
+
+    def self.infer_spin?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::INFER_SPIN,
+        env_variables: env_variables
+      )
     end
 
     def self.spin_url(env_variables: ENV)
-      spin_workspace = spin_workspace(env_variables: env_variables)
-      spin_namespace = spin_namespace(env_variables: env_variables)
-      spin_host = spin_host(env_variables: env_variables)
-      "#{spin_workspace}.#{spin_namespace}.#{spin_host}"
+      if infer_spin?(env_variables: env_variables)
+        %x(spin info fqdn 2> /dev/null).strip
+      else
+        spin_workspace = spin_workspace(env_variables: env_variables)
+        spin_namespace = spin_namespace(env_variables: env_variables)
+        spin_host = spin_host(env_variables: env_variables)
+        "#{spin_workspace}.#{spin_namespace}.#{spin_host}"
+      end
     end
 
     def self.send_monorail_events?(env_variables: ENV)
@@ -106,11 +115,21 @@ module ShopifyCLI
     end
 
     def self.spin_workspace(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::SPIN_WORKSPACE]
+      env_value = env_variables[Constants::EnvironmentVariables::SPIN_WORKSPACE]
+      return env_value unless env_value.nil?
+
+      if env_value.nil?
+        raise "No value set for #{Constants::EnvironmentVariables::SPIN_WORKSPACE}"
+      end
     end
 
     def self.spin_namespace(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::SPIN_NAMESPACE]
+      env_value = env_variables[Constants::EnvironmentVariables::SPIN_NAMESPACE]
+      return env_value unless env_value.nil?
+
+      if env_value.nil?
+        raise "No value set for #{Constants::EnvironmentVariables::SPIN_NAMESPACE}"
+      end
     end
 
     def self.spin_host(env_variables: ENV)

data/lib/shopify_cli/identity_auth.rb

@@ -256,7 +256,7 @@ module ShopifyCLI
     def auth_url
       if Environment.use_local_partners_instance?
         "https://identity.myshopify.io/oauth"
-      elsif Environment.use_spin_partners_instance?
+      elsif Environment.use_spin?
         "https://identity.#{Environment.spin_url}/oauth"
       else
         "https://accounts.shopify.com/oauth"
@@ -264,7 +264,7 @@ module ShopifyCLI
     end
 
     def client_id_for_application(application_name)
-      client_ids = if Environment.use_local_partners_instance? || Environment.use_spin_partners_instance?
+      client_ids = if Environment.use_local_partners_instance? || Environment.use_spin?
         DEV_APPLICATION_CLIENT_IDS
       else
         APPLICATION_CLIENT_IDS
@@ -280,7 +280,7 @@ module ShopifyCLI
     end
 
     def client_id
-      if Environment.use_local_partners_instance? || Environment.use_spin_partners_instance?
+      if Environment.use_local_partners_instance? || Environment.use_spin?
         Constants::Identity::CLIENT_ID_DEV
       else
         # In the future we might want to use Identity's dynamic

data/lib/shopify_cli/messages/messages.rb

@@ -415,7 +415,7 @@ module ShopifyCLI
               Usage: {{command:%s login [--store=STORE]}}
           HELP
           invalid_shop: <<~MESSAGE,
-            Invalid store provided (%s). Please make sure that the store belongs to your partner organization, and provide the store in the following format: my-store.myshopify.com
+            Invalid store provided (%s). Please provide the store in the following format: my-store.myshopify.com
           MESSAGE
           shop_prompt: <<~PROMPT,
             What store are you connecting to? (e.g. my-store.myshopify.com; do {{bold:NOT}} include protocol part, e.g., https://)

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/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/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

data/lib/shopify_cli/theme/dev_server.rb

@@ -3,6 +3,7 @@ require_relative "development_theme"
 require_relative "ignore_filter"
 require_relative "syncer"
 
+require_relative "dev_server/cdn_assets"
 require_relative "dev_server/cdn_fonts"
 require_relative "dev_server/hot_reload"
 require_relative "dev_server/header_hash"
@@ -37,6 +38,7 @@ module ShopifyCLI
           @app = Proxy.new(ctx, theme: theme, syncer: @syncer)
           @app = CdnFonts.new(@app, theme: theme)
           @app = LocalAssets.new(ctx, @app, theme: theme)
+          @app = CdnAssets.new(@app, theme: theme)
           @app = HotReload.new(ctx, @app, theme: theme, watcher: watcher, mode: mode, ignore_filter: ignore_filter)
           stopped = false
           address = "http://#{host}:#{port}"

data/lib/shopify_cli/theme/file.rb

@@ -18,7 +18,7 @@ module ShopifyCLI
 
       def read
         if text?
-          path.read
+          path.read(universal_newline: true)
         else
           path.read(mode: "rb")
         end
@@ -27,7 +27,7 @@ module ShopifyCLI
       def write(content)
         path.parent.mkpath unless path.parent.directory?
         if text?
-          path.write(content)
+          path.write(content, universal_newline: true)
         else
           path.write(content, 0, mode: "wb")
         end

data/lib/shopify_cli/theme/filter/path_matcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    module Filter
+      module PathMatcher
+        def regex_match?(regex, path)
+          regex.match?(path)
+        rescue StandardError
+          false
+        end
+
+        def glob_match?(glob, path)
+          !!::File.fnmatch?(glob, path)
+        end
+
+        def regex?(pattern)
+          pattern.start_with?("/") && pattern.end_with?("/")
+        end
+
+        def as_regex(pattern)
+          Regexp.new(pattern.gsub(%r{^\/|\/$}, ""))
+        end
+
+        def as_glob(pattern)
+          # if specifying a directory, match everything below it
+          pattern += "*" if pattern.end_with?("/")
+
+          # The pattern will be scoped to root directory, so it should match anything
+          # within that space
+          pattern.prepend("*") unless pattern.start_with?("*")
+
+          pattern
+        end
+      end
+    end
+  end
+end