shopify-cli 2.2.0 → 2.4.0

data/lib/project_types/script/graphql/app_script_update_or_create.graphql

@@ -1,44 +0,0 @@
-mutation AppScriptUpdateOrCreate(
-  $extensionPointName: ExtensionPointName!,
-  $title: String,
-  $description: String,
-  $sourceCode: String,
-  $language: String,
-  $force: Boolean,
-  $schemaMajorVersion: String,
-  $schemaMinorVersion: String,
-  $useMsgpack: Boolean,
-  $uuid: String,
-  $configurationUi: Boolean!,
-  $scriptJsonVersion: String!,
-  $configurationDefinition: String!,
-) {
-  appScriptUpdateOrCreate(
-    extensionPointName: $extensionPointName
-    title: $title
-    description: $description
-    sourceCode: $sourceCode
-    language: $language
-    force: $force
-    schemaMajorVersion: $schemaMajorVersion
-    schemaMinorVersion: $schemaMinorVersion
-    useMsgpack: $useMsgpack,
-    uuid: $uuid
-    configurationUi: $configurationUi
-    scriptJsonVersion: $scriptJsonVersion
-    configurationDefinition: $configurationDefinition
-) {
-    userErrors {
-      field
-      message
-      tag
-    }
-    appScript {
-      uuid
-      appKey
-      configSchema
-      extensionPointName
-      title
-    }
-  }
-}

data/lib/project_types/script/graphql/module_upload_url_generate.graphql

@@ -0,0 +1,9 @@
+mutation moduleUploadUrlGenerate {
+  moduleUploadUrlGenerate {
+    url
+    userErrors {
+      field
+      message
+    }
+  }
+}

data/lib/project_types/script/layers/application/push_script.rb

@@ -20,7 +20,16 @@ module Script
                 compiled_type: task_runner.compiled_type,
                 metadata: task_runner.metadata,
               )
-              uuid = package.push(Infrastructure::ScriptService.new(ctx: p_ctx), script_project.api_key, force)
+              script_service = Infrastructure::ScriptService.new(ctx: p_ctx, api_key: script_project.api_key)
+              module_upload_url = Infrastructure::ScriptUploader.new(script_service).upload(package.script_content)
+              uuid = script_service.set_app_script(
+                uuid: package.uuid,
+                extension_point_type: package.extension_point_type,
+                force: force,
+                metadata: package.metadata,
+                script_json: package.script_json,
+                module_upload_url: module_upload_url,
+              )
               script_project_repo.update_env(uuid: uuid)
               spinner.update_title(p_ctx.message("script.application.pushed"))
             end

data/lib/project_types/script/layers/domain/push_package.rb

@@ -17,7 +17,7 @@ module Script
           uuid:,
           extension_point_type:,
           script_content:,
-          compiled_type:,
+          compiled_type: nil,
           metadata:,
           script_json:
         )
@@ -29,19 +29,6 @@ module Script
           @metadata = metadata
           @script_json = script_json
         end
-
-        def push(script_service, api_key, force)
-          script_service.push(
-            uuid: @uuid,
-            extension_point_type: @extension_point_type,
-            script_content: @script_content,
-            compiled_type: @compiled_type,
-            api_key: api_key,
-            force: force,
-            metadata: @metadata,
-            script_json: @script_json,
-          )
-        end
       end
     end
   end

data/lib/project_types/script/layers/infrastructure/api_clients.rb

@@ -0,0 +1,89 @@
+module Script
+  module Layers
+    module Infrastructure
+      class ApiClients
+        def self.default_client(ctx, api_key)
+          if ENV["BYPASS_PARTNERS_PROXY"]
+            ScriptServiceApiClient.new(ctx, api_key)
+          else
+            PartnersProxyApiClient.new(ctx, api_key)
+          end
+        end
+
+        class ScriptServiceApiClient
+          LOCAL_INSTANCE_URL = "https://script-service.myshopify.io"
+
+          def initialize(ctx, api_key)
+            instance_url = script_service_url
+            @api = ShopifyCli::API.new(
+              ctx: ctx,
+              url: "#{instance_url}/graphql",
+              token: { "APP_KEY" => api_key }.compact.to_json,
+              auth_header: "X-Shopify-Authenticated-Tokens"
+            )
+          end
+
+          def query(query_name, variables: {})
+            @api.query(query_name, variables: variables)
+          end
+
+          private
+
+          def script_service_url
+            if ::ShopifyCli::Environment.use_spin_partners_instance?
+              "https://script-service.#{::ShopifyCli::Environment.spin_url}"
+            else
+              LOCAL_INSTANCE_URL
+            end
+          end
+        end
+        private_constant(:ScriptServiceApiClient)
+
+        class PartnersProxyApiClient
+          def initialize(ctx, api_key)
+            @ctx = ctx
+            @api_key = api_key
+          end
+
+          def query(query_name, variables: {})
+            response = ShimAPI.query(@ctx, query_name, api_key: @api_key, variables: variables.to_json)
+            raise_if_graphql_failed(response)
+            JSON.parse(response["data"]["scriptServiceProxy"])
+          end
+
+          def raise_if_graphql_failed(response)
+            raise Errors::EmptyResponseError if response.nil?
+
+            return unless response.key?("errors")
+            case error_code(response["errors"])
+            when "forbidden"
+              raise Errors::ForbiddenError
+            when "forbidden_on_shop"
+              raise Errors::ShopAuthenticationError
+            when "app_not_installed_on_shop"
+              raise Errors::AppNotInstalledError
+            else
+              raise Errors::GraphqlError, response["errors"]
+            end
+          end
+
+          def error_code(errors)
+            errors.map do |e|
+              code = e.dig("extensions", "code")
+              return code if code
+            end
+          end
+
+          class ShimAPI < ShopifyCli::PartnersAPI
+            def query(query_name, variables: {})
+              variables[:query] = load_query(query_name)
+              super("script_service_proxy", variables: variables)
+            end
+          end
+          private_constant(:ShimAPI)
+        end
+        private_constant(:PartnersProxyApiClient)
+      end
+    end
+  end
+end

data/lib/project_types/script/layers/infrastructure/errors.rb

@@ -93,6 +93,8 @@ module Script
             super("WebAssembly binary not found")
           end
         end
+
+        class ScriptUploadError < ScriptProjectError; end
       end
     end
   end

data/lib/project_types/script/layers/infrastructure/languages/assemblyscript_project_creator.rb

@@ -40,7 +40,7 @@ module Script
           def extension_point_version
             return extension_point.sdks.assemblyscript.version if extension_point.sdks.assemblyscript.versioned?
 
-            out = command_runner.call("npm show #{extension_point.sdks.assemblyscript.package} version --json")
+            out = command_runner.call("npm -s show #{extension_point.sdks.assemblyscript.package} version --json")
             "^#{JSON.parse(out)}"
           end
 

data/lib/project_types/script/layers/infrastructure/push_package_repository.rb

@@ -32,7 +32,6 @@ module Script
             uuid: script_project.uuid,
             extension_point_type: script_project.extension_point_type,
             script_content: script_content,
-            compiled_type: compiled_type,
             metadata: metadata,
             script_json: script_project.script_json,
           )

data/lib/project_types/script/layers/infrastructure/script_service.rb

@@ -9,37 +9,39 @@ module Script
       class ScriptService
         include SmartProperties
         property! :ctx, accepts: ShopifyCli::Context
+        property! :api_key, accepts: String
 
-        def push(
+        def initialize(*args, ctx:, api_key:, **kwargs)
+          super(*args, ctx: ctx, api_key: api_key, **kwargs)
+          @client = ApiClients.default_client(ctx, api_key)
+        end
+
+        def set_app_script(
           uuid:,
           extension_point_type:,
-          script_content:,
-          compiled_type:,
-          api_key: nil,
           force: false,
           metadata:,
-          script_json:
+          script_json:,
+          module_upload_url:
         )
-          query_name = "app_script_update_or_create"
+          query_name = "app_script_set"
           variables = {
             uuid: uuid,
             extensionPointName: extension_point_type.upcase,
             title: script_json.title,
             description: script_json.description,
-            sourceCode: Base64.encode64(script_content),
-            language: compiled_type,
             force: force,
             schemaMajorVersion: metadata.schema_major_version.to_s, # API expects string value
             schemaMinorVersion: metadata.schema_minor_version.to_s, # API expects string value
-            useMsgpack: metadata.use_msgpack,
             scriptJsonVersion: script_json.version,
             configurationUi: script_json.configuration_ui,
             configurationDefinition: script_json.configuration&.to_json,
+            moduleUploadUrl: module_upload_url,
           }
-          resp_hash = script_service_request(query_name: query_name, api_key: api_key, variables: variables)
-          user_errors = resp_hash["data"]["appScriptUpdateOrCreate"]["userErrors"]
+          resp_hash = make_request(query_name: query_name, variables: variables)
+          user_errors = resp_hash["data"]["appScriptSet"]["userErrors"]
 
-          return resp_hash["data"]["appScriptUpdateOrCreate"]["appScript"]["uuid"] if user_errors.empty?
+          return resp_hash["data"]["appScriptSet"]["appScript"]["uuid"] if user_errors.empty?
 
           if user_errors.any? { |e| e["tag"] == "already_exists_error" }
             raise Errors::ScriptRepushError, uuid
@@ -64,98 +66,31 @@ module Script
           end
         end
 
-        def get_app_scripts(api_key:, extension_point_type:)
+        def get_app_scripts(extension_point_type:)
           query_name = "get_app_scripts"
           variables = { appKey: api_key, extensionPointName: extension_point_type.upcase }
-          script_service_request(query_name: query_name, api_key: api_key, variables: variables)["data"]["appScripts"]
+          response = make_request(query_name: query_name, variables: variables)
+          response["data"]["appScripts"]
         end
 
-        private
-
-        class ScriptServiceAPI < ShopifyCli::API
-          property(:api_key, accepts: String)
+        def generate_module_upload_url
+          query_name = "module_upload_url_generate"
+          variables = {}
+          response = make_request(query_name: query_name, variables: variables)
+          user_errors = response["data"]["moduleUploadUrlGenerate"]["userErrors"]
 
-          LOCAL_INSTANCE_URL = "https://script-service.myshopify.io"
-
-          def self.query(ctx, query_name, api_key: nil, variables: {})
-            api_client(ctx, api_key).query(query_name, variables: variables)
-          end
-
-          def self.api_client(ctx, api_key)
-            instance_url = spin_instance_url || LOCAL_INSTANCE_URL
-            new(
-              ctx: ctx,
-              url: "#{instance_url}/graphql",
-              token: "",
-              api_key: api_key
-            )
-          end
-
-          def self.spin_instance_url
-            workspace = ENV["SPIN_WORKSPACE"]
-            namespace = ENV["SPIN_NAMESPACE"]
-            return if workspace.nil? || namespace.nil?
-
-            "https://script-service.#{workspace}.#{namespace}.us.spin.dev"
-          end
-
-          def auth_headers(*)
-            tokens = { "APP_KEY" => api_key }.compact.to_json
-            { "X-Shopify-Authenticated-Tokens" => tokens }
-          end
+          raise Errors::GraphqlError, user_errors if user_errors.any?
+          response["data"]["moduleUploadUrlGenerate"]["url"]
         end
-        private_constant(:ScriptServiceAPI)
 
-        class PartnersProxyAPI < ShopifyCli::PartnersAPI
-          def query(query_name, variables: {})
-            variables[:query] = load_query(query_name)
-            super("script_service_proxy", variables: variables)
-          end
-        end
-        private_constant(:PartnersProxyAPI)
-
-        def script_service_request(query_name:, variables: nil, **options)
-          resp = if bypass_partners_proxy
-            ScriptServiceAPI.query(ctx, query_name, variables: variables, **options)
-          else
-            proxy_through_partners(query_name: query_name, variables: variables, **options)
-          end
-          raise_if_graphql_failed(resp)
-          resp
-        end
-
-        def bypass_partners_proxy
-          !ENV["BYPASS_PARTNERS_PROXY"].nil?
-        end
-
-        def proxy_through_partners(query_name:, variables: nil, **options)
-          options[:variables] = variables.to_json if variables
-          resp = PartnersProxyAPI.query(ctx, query_name, **options)
-          raise_if_graphql_failed(resp)
-          JSON.parse(resp["data"]["scriptServiceProxy"])
-        end
+        private
 
-        def raise_if_graphql_failed(response)
+        def make_request(query_name:, variables: {})
+          response = @client.query(query_name, variables: variables)
           raise Errors::EmptyResponseError if response.nil?
+          raise Errors::GraphqlError, response["errors"] if response.key?("errors")
 
-          return unless response.key?("errors")
-          case error_code(response["errors"])
-          when "forbidden"
-            raise Errors::ForbiddenError
-          when "forbidden_on_shop"
-            raise Errors::ShopAuthenticationError
-          when "app_not_installed_on_shop"
-            raise Errors::AppNotInstalledError
-          else
-            raise Errors::GraphqlError, response["errors"]
-          end
-        end
-
-        def error_code(errors)
-          errors.map do |e|
-            code = e.dig("extensions", "code")
-            return code if code
-          end
+          response
         end
       end
     end

data/lib/project_types/script/layers/infrastructure/script_uploader.rb

@@ -0,0 +1,27 @@
+module Script
+  module Layers
+    module Infrastructure
+      class ScriptUploader
+        def initialize(script_service)
+          @script_service = script_service
+        end
+
+        def upload(script_content)
+          @script_service.generate_module_upload_url.tap do |url|
+            url = URI(url)
+
+            https = Net::HTTP.new(url.host, url.port)
+            https.use_ssl = true
+
+            request = Net::HTTP::Put.new(url)
+            request["Content-Type"] = "application/wasm"
+            request.body = script_content
+
+            response = https.request(request)
+            raise Errors::ScriptUploadError unless response.code == "200"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/project_types/script/messages/messages.rb

@@ -141,6 +141,9 @@ module Script
           web_assembly_binary_not_found_suggestion: "No WebAssembly binary found." \
             "Check that your build npm script outputs the generated binary to the root of the directory." \
             "Generated binary should match the script name: <script_name>.wasm",
+
+          script_upload_cause: "Fail to upload script.",
+          script_upload_help: "Try again.",
         },
 
         create: {

data/lib/project_types/script/tasks/ensure_env.rb

@@ -89,8 +89,8 @@ module Script
       end
 
       def ask_script_uuid(app, extension_point_type)
-        script_service = Layers::Infrastructure::ScriptService.new(ctx: ctx)
-        scripts = script_service.get_app_scripts(api_key: app["apiKey"], extension_point_type: extension_point_type)
+        script_service = Layers::Infrastructure::ScriptService.new(ctx: ctx, api_key: app["apiKey"])
+        scripts = script_service.get_app_scripts(extension_point_type: extension_point_type)
 
         return nil unless scripts.count > 0 &&
           CLI::UI::Prompt.confirm(ctx.message("script.application.ensure_env.ask_connect_to_existing_script"))

data/lib/project_types/script/ui/error_handler.rb

@@ -99,7 +99,7 @@ module Script
             cause_of_error: ShopifyCli::Context.message("script.error.invalid_extension_cause", e.type),
             help_suggestion: ShopifyCli::Context.message(
               "script.error.invalid_extension_help",
-              Script::Layers::Application::ExtensionPoints.types.join(", ")
+              Script::Layers::Application::ExtensionPoints.available_types.join(", ")
             ),
           }
         when Layers::Domain::Errors::ScriptNotFoundError
@@ -237,6 +237,11 @@ module Script
             cause_of_error: ShopifyCli::Context.message("script.error.web_assembly_binary_not_found"),
             help_suggestion: ShopifyCli::Context.message("script.error.web_assembly_binary_not_found_suggestion"),
           }
+        when Layers::Infrastructure::Errors::ScriptUploadError
+          {
+            cause_of_error: ShopifyCli::Context.message("script.error.script_upload_cause"),
+            help_suggestion: ShopifyCli::Context.message("script.error.script_upload_help"),
+          }
         end
       end
     end

data/lib/project_types/theme/commands/pull.rb

@@ -9,6 +9,10 @@ module Theme
       options do |parser, flags|
         parser.on("-n", "--nodelete") { flags[:nodelete] = true }
         parser.on("-i", "--themeid=ID") { |theme_id| flags[:theme_id] = theme_id }
+        parser.on("-x", "--ignore=PATTERN") do |pattern|
+          flags[:ignores] ||= []
+          flags[:ignores] << pattern
+        end
       end
 
       def call(args, _name)
@@ -29,6 +33,8 @@ module Theme
         end
 
         ignore_filter = ShopifyCli::Theme::IgnoreFilter.from_path(root)
+        ignore_filter.add_patterns(options.flags[:ignores]) if options.flags[:ignores]
+
         syncer = ShopifyCli::Theme::Syncer.new(@ctx, theme: theme, ignore_filter: ignore_filter)
         begin
           syncer.start_threads

data/lib/project_types/theme/commands/push.rb

@@ -15,6 +15,10 @@ module Theme
         parser.on("-j", "--json") { flags[:json] = true }
         parser.on("-a", "--allow-live") { flags[:allow_live] = true }
         parser.on("-p", "--publish") { flags[:publish] = true }
+        parser.on("-x", "--ignore=PATTERN") do |pattern|
+          flags[:ignores] ||= []
+          flags[:ignores] << pattern
+        end
       end
 
       def call(args, _name)
@@ -48,6 +52,8 @@ module Theme
         end
 
         ignore_filter = ShopifyCli::Theme::IgnoreFilter.from_path(root)
+        ignore_filter.add_patterns(options.flags[:ignores]) if options.flags[:ignores]
+
         syncer = ShopifyCli::Theme::Syncer.new(@ctx, theme: theme, ignore_filter: ignore_filter)
         begin
           syncer.start_threads

data/lib/shopify-cli/constants.rb

@@ -0,0 +1,26 @@
+module ShopifyCli
+  module Constants
+    module EnvironmentVariables
+      # When true the CLI points to a local instance of
+      # 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"
+
+      SPIN_WORKSPACE = "SPIN_WORKSPACE"
+
+      SPIN_NAMESPACE = "SPIN_NAMESPACE"
+
+      SPIN_HOST = "SPIN_HOST"
+
+      # Set to true when running tests.
+      RUNNING_TESTS = "RUNNING_SHOPIFY_CLI_TESTS"
+    end
+
+    module Identity
+      CLIENT_ID_DEV = "e5380e02-312a-7408-5718-e07017e9cf52"
+      CLIENT_ID = "fbdb2649-e327-4907-8f67-908d24cfd7e3"
+    end
+  end
+end

data/lib/shopify-cli/environment.rb

@@ -0,0 +1,60 @@
+module ShopifyCli
+  # The environment module provides an interface to get information from
+  # the environment in which the CLI runs
+  module Environment
+    TRUTHY_ENV_VARIABLE_VALUES = ["1", "true", "TRUE", "yes", "YES"]
+    def self.use_local_partners_instance?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::LOCAL_PARTNERS,
+        env_variables: env_variables
+      )
+    end
+
+    def self.use_spin_partners_instance?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::SPIN_PARTNERS,
+        env_variables: env_variables
+      )
+    end
+
+    def self.running_tests?(env_variables: ENV)
+      env_variable_truthy?(
+        Constants::EnvironmentVariables::RUNNING_TESTS,
+        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)
+        "partners.#{spin_url(env_variables: env_variables)}"
+      else
+        "partners.shopify.com"
+      end
+    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}"
+    end
+
+    def self.env_variable_truthy?(variable_name, env_variables: ENV)
+      TRUTHY_ENV_VARIABLE_VALUES.include?(env_variables[variable_name.to_s])
+    end
+
+    def self.spin_workspace(env_variables: ENV)
+      env_variables[Constants::EnvironmentVariables::SPIN_WORKSPACE]
+    end
+
+    def self.spin_namespace(env_variables: ENV)
+      env_variables[Constants::EnvironmentVariables::SPIN_NAMESPACE]
+    end
+
+    def self.spin_host(env_variables: ENV)
+      env_variables[Constants::EnvironmentVariables::SPIN_HOST] || "us.spin.dev"
+    end
+  end
+end

data/lib/shopify-cli/git.rb

@@ -108,8 +108,8 @@ module ShopifyCli
       private
 
       def exec(*args, dir: Dir.pwd, default: nil, ctx: Context.new)
-        args = %w(git) + args
-        out, _, stat = ctx.capture3(*args, chdir: dir)
+        args = %w(git) + ["--git-dir", File.join(dir, ".git")] + args
+        out, _, stat = ctx.capture3(*args)
         return default unless stat.success?
         out.chomp
       end

data/lib/shopify-cli/identity_auth.rb

@@ -17,7 +17,6 @@ module ShopifyCli
     class Error < StandardError; end
     class Timeout < StandardError; end
     LocalRequest = Struct.new(:method, :path, :query, :protocol)
-    LOCAL_DEBUG = "SHOPIFY_APP_CLI_LOCAL_PARTNERS"
 
     DEFAULT_PORT = 3456
     REDIRECT_HOST = "http://127.0.0.1:#{DEFAULT_PORT}"
@@ -236,12 +235,17 @@ module ShopifyCli
     end
 
     def auth_url
-      return "https://accounts.shopify.com/oauth" if ENV[LOCAL_DEBUG].nil?
-      "https://identity.myshopify.io/oauth"
+      if Environment.use_local_partners_instance?
+        "https://identity.myshopify.io/oauth"
+      elsif Environment.use_spin_partners_instance?
+        "https://identity.#{Environment.spin_url}/oauth"
+      else
+        "https://accounts.shopify.com/oauth"
+      end
     end
 
     def client_id_for_application(application_name)
-      client_ids = if ENV[LOCAL_DEBUG]
+      client_ids = if Environment.use_local_partners_instance? || Environment.use_spin_partners_instance?
         DEV_APPLICATION_CLIENT_IDS
       else
         APPLICATION_CLIENT_IDS
@@ -257,26 +261,15 @@ module ShopifyCli
     end
 
     def client_id
-      return "fbdb2649-e327-4907-8f67-908d24cfd7e3" if ENV[LOCAL_DEBUG].nil?
-
-      ctx.abort(ctx.message("core.identity_auth.error.local_identity_not_running")) unless local_identity_running?
-
-      # Fetch the client ID from the local Identity Dynamic Registration endpoint
-      response = post_request("/client", {
-        name: "shopify-cli-development",
-        public_type: "native",
-      })
-
-      response["client_id"]
-    end
-
-    def local_identity_running?
-      Net::HTTP.start("identity.myshopify.io", 443, use_ssl: true, open_timeout: 1, read_timeout: 10) do |http|
-        req = Net::HTTP::Get.new(URI.join("https://identity.myshopify.io", "/services/ping"))
-        http.request(req).is_a?(Net::HTTPSuccess)
+      if Environment.use_local_partners_instance? || Environment.use_spin_partners_instance?
+        Constants::Identity::CLIENT_ID_DEV
+      else
+        # In the future we might want to use Identity's dynamic
+        # registration. To migrate to a dynamic client ID we
+        # need to refactor some code that relies on a static
+        # value for the client
+        Constants::Identity::CLIENT_ID
       end
-    rescue Timeout::Error, Errno::EHOSTUNREACH, Errno::EHOSTDOWN, Errno::EADDRNOTAVAIL, Errno::ECONNREFUSED
-      false
     end
   end
 end