shopify-cli 2.25.0 → 2.27.0

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

@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-module Script
-  module Layers
-    module Infrastructure
-      class ScriptProjectRepository
-        include SmartProperties
-        property! :ctx, accepts: ShopifyCLI::Context
-        property :directory, accepts: String
-        property :initial_directory, accepts: String
-
-        MUTABLE_ENV_VALUES = %i(uuid)
-        INPUT_QUERY_PATH = "input.graphql"
-
-        def create_project_directory
-          raise Infrastructure::Errors::ScriptProjectAlreadyExistsError, directory if ctx.dir_exist?(directory)
-          ctx.mkdir_p(directory)
-          change_directory(directory: directory)
-        end
-
-        def delete_project_directory
-          change_to_initial_directory
-          ctx.rm_r(directory)
-        end
-
-        def change_to_initial_directory
-          change_directory(directory: initial_directory)
-        end
-
-        def create(title:, extension_point_type:, language:)
-          validate_metadata!(extension_point_type, language)
-
-          ShopifyCLI::Project.write(
-            ctx,
-            project_type: :script,
-            organization_id: nil,
-            extension_point_type: extension_point_type,
-            title: title,
-            description: nil,
-            language: language,
-            app_bridge_create_path: "/",
-            app_bridge_details_path: "/",
-          )
-
-          build_script_project(script_config: nil)
-        end
-
-        def get
-          validate_metadata!(extension_point_type, language)
-
-          Domain::ScriptProject.new(
-            id: project.directory,
-            env: project.env,
-            title: title,
-            description: description,
-            extension_point_type: extension_point_type,
-            language: language,
-            script_config: script_config_repository.get!,
-            app_bridge: app_bridge,
-            input_query: read_input_query,
-          )
-        end
-
-        def update_env(**args)
-          capture_io do
-            args.slice(*MUTABLE_ENV_VALUES).each do |key, value|
-              project.env.extra[key.to_s.upcase] = value
-              project.env.update(ctx, :extra, project.env.extra)
-            end
-          end
-
-          build_script_project
-        end
-
-        def create_env(api_key:, secret:, uuid:)
-          ShopifyCLI::Resources::EnvFile.new(
-            api_key: api_key,
-            secret: secret,
-            extra: {
-              Domain::ScriptProject::UUID_ENV_KEY => uuid,
-            }
-          ).write(ctx)
-
-          build_script_project
-        end
-
-        private
-
-        def build_script_project(
-          script_config: script_config_repository.get!
-        )
-          Domain::ScriptProject.new(
-            id: ctx.root,
-            env: project.env,
-            title: title,
-            description: description,
-            extension_point_type: extension_point_type,
-            language: language,
-            script_config: script_config,
-            app_bridge: app_bridge,
-          )
-        end
-
-        def change_directory(directory:)
-          ctx.chdir(directory)
-        end
-
-        def capture_io(&block)
-          CLI::UI::StdoutRouter::Capture.new(&block).run
-        end
-
-        def extension_point_type
-          project_config_value!("extension_point_type")
-        end
-
-        def title
-          project_config_value!("title")
-        end
-
-        def description
-          project_config_value("description")
-        end
-
-        def language
-          project_config_value("language")&.downcase || default_language
-        end
-
-        def app_bridge
-          create_path = project_config_value!("app_bridge_create_path")
-          details_path = project_config_value!("app_bridge_details_path")
-
-          Domain::AppBridge.new(
-            create_path: create_path,
-            details_path: details_path,
-          )
-        end
-
-        def project_config_value(key)
-          return nil unless project.config.key?(key)
-          project.config[key]
-        end
-
-        def project_config_value!(key)
-          raise Errors::InvalidContextError, key unless project.config.key?(key)
-          project.config[key]
-        end
-
-        def project
-          @project ||= ShopifyCLI::Project.current(force_reload: true)
-        end
-
-        def default_language
-          "wasm"
-        end
-
-        def validate_metadata!(extension_point_type, language)
-          if Application::ExtensionPoints.deprecated_types.include?(extension_point_type)
-            raise Errors::DeprecatedEPError, extension_point_type
-          elsif !Application::ExtensionPoints.supported_language?(type: extension_point_type, language: language)
-            raise Errors::InvalidLanguageError.new(language, extension_point_type)
-          end
-        end
-
-        def script_config_repository
-          @script_config_repository ||= begin
-            script_config_yml_repo = ScriptConfigYmlRepository.new(ctx: ctx)
-            supported_repos = [
-              script_config_yml_repo,
-              ScriptJsonRepository.new(ctx: ctx),
-            ]
-            repo = supported_repos.find(&:active?)
-            if repo.nil?
-              raise Infrastructure::Errors::NoScriptConfigFileError, script_config_yml_repo.filename
-            end
-            repo
-          end
-        end
-
-        def read_input_query
-          ctx.read(INPUT_QUERY_PATH) if ctx.file_exist?(INPUT_QUERY_PATH)
-        end
-
-        class ScriptConfigRepository
-          include SmartProperties
-          property! :ctx, accepts: ShopifyCLI::Context
-
-          def active?
-            ctx.file_exist?(filename)
-          end
-
-          def get!
-            raise Infrastructure::Errors::NoScriptConfigFileError, filename unless active?
-
-            content = ctx.read(filename)
-            hash = file_content_to_hash(content)
-
-            from_h(hash)
-          end
-
-          def filename
-            raise NotImplementedError
-          end
-
-          private
-
-          def from_h(hash)
-            Domain::ScriptConfig.new(content: hash, filename: filename)
-          end
-
-          def file_content_to_hash(file_content)
-            raise NotImplementedError
-          end
-
-          def hash_to_file_content(hash)
-            raise NotImplementedError
-          end
-        end
-
-        class ScriptConfigYmlRepository < ScriptConfigRepository
-          def filename
-            "script.config.yml"
-          end
-
-          private
-
-          def file_content_to_hash(file_content)
-            begin
-              hash = YAML.load(file_content)
-            rescue Psych::SyntaxError
-              raise parse_error
-            end
-            raise parse_error unless hash.is_a?(Hash)
-            hash
-          end
-
-          def hash_to_file_content(hash)
-            YAML.dump(hash)
-          end
-
-          def parse_error
-            Errors::ScriptConfigParseError.new(filename: filename, serialization_format: "YAML")
-          end
-        end
-
-        class ScriptJsonRepository < ScriptConfigRepository
-          def filename
-            "script.json"
-          end
-
-          private
-
-          def file_content_to_hash(file_content)
-            begin
-              hash = JSON.parse(file_content)
-            rescue JSON::ParserError
-              raise parse_error
-            end
-            raise parse_error unless hash.is_a?(Hash)
-            hash
-          end
-
-          def hash_to_file_content(hash)
-            JSON.pretty_generate(hash)
-          end
-
-          def parse_error
-            Errors::ScriptConfigParseError.new(filename: filename, serialization_format: "JSON")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require "json"
-
-module Script
-  module Layers
-    module Infrastructure
-      class ScriptService
-        def initialize(client:, api_key:)
-          @client = client
-          @api_key = api_key
-        end
-
-        def set_app_script(
-          uuid:,
-          extension_point_type:,
-          title:,
-          description:,
-          force: false,
-          metadata:,
-          script_config:,
-          app_bridge:,
-          module_upload_url:,
-          library:,
-          input_query: nil
-        )
-          query_name = "app_script_set"
-          variables = {
-            uuid: uuid,
-            extensionPointName: extension_point_type.upcase,
-            title: title,
-            description: description,
-            force: force,
-            schemaMajorVersion: metadata.schema_major_version.to_s, # API expects string value
-            schemaMinorVersion: metadata.schema_minor_version.to_s, # API expects string value
-            scriptConfigVersion: script_config.version,
-            configurationUi: script_config.configuration_ui,
-            configurationDefinition: script_config.configuration&.to_json,
-            appBridge: {
-              createPath: app_bridge.create_path,
-              detailsPath: app_bridge.details_path,
-            },
-            moduleUploadUrl: module_upload_url,
-            inputQuery: input_query,
-          }
-
-          variables[:library] = {
-            language: library[:language],
-            version: library[:version],
-          }  if library
-
-          resp_hash = make_request(query_name: query_name, variables: variables)
-          user_errors = resp_hash["data"]["appScriptSet"]["userErrors"]
-
-          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
-          elsif (errors = user_errors.select { |err| err["tag"] == "configuration_definition_error" }).any?
-            raise Errors::ScriptConfigurationDefinitionError.new(
-              messages: errors.map { |e| e["message"] },
-              filename: script_config.filename,
-            )
-          elsif (e = user_errors.any? { |err| err["tag"] == "configuration_definition_syntax_error" })
-            raise Errors::ScriptConfigSyntaxError, script_config.filename
-          elsif (e = user_errors.find { |err| err["tag"] == "configuration_definition_missing_keys_error" })
-            raise Errors::ScriptConfigMissingKeysError.new(
-              missing_keys: e["message"],
-              filename: script_config.filename,
-            )
-          elsif (e = user_errors.find { |err| err["tag"] == "configuration_definition_invalid_value_error" })
-            raise Errors::ScriptConfigInvalidValueError.new(
-              valid_input_modes: e["message"],
-              filename: script_config.filename,
-            )
-          elsif (e = user_errors.find do |err|
-                   err["tag"] == "configuration_definition_schema_field_missing_keys_error"
-                 end)
-            raise Errors::ScriptConfigFieldsMissingKeysError.new(
-              missing_keys: e["message"],
-              filename: script_config.filename,
-            )
-          elsif (e = user_errors.find do |err|
-                   err["tag"] == "configuration_definition_schema_field_invalid_value_error"
-                 end)
-            raise Errors::ScriptConfigFieldsInvalidValueError.new(
-              valid_types: e["message"],
-              filename: script_config.filename,
-            )
-          elsif (errors = user_errors.filter { |err| err["tag"] == "input_query_validation_error" }).any?
-            raise Errors::InvalidInputQueryErrors, errors.map { |err| err["message"] }
-          elsif user_errors.find { |err| %w(schema_version_argument_error).include?(err["tag"]) }
-            raise Domain::Errors::MetadataValidationError
-          elsif user_errors.find { |err| err["tag"] == "invalid_app_bridge_create_path" }
-            raise Errors::InvalidAppBridgePathError, "create"
-          elsif user_errors.find { |err| err["tag"] == "invalid_app_bridge_details_path" }
-            raise Errors::InvalidAppBridgePathError, "details"
-          else
-            raise Errors::GraphqlError, user_errors
-          end
-        end
-
-        def get_app_scripts(extension_point_type:)
-          query_name = "get_app_scripts"
-          variables = { appKey: @api_key, extensionPointName: extension_point_type.upcase }
-          response = make_request(query_name: query_name, variables: variables)
-          response["data"]["appScripts"]
-        end
-
-        def generate_module_upload_details
-          query_name = "module_upload_url_generate"
-          variables = {}
-          response = make_request(query_name: query_name, variables: variables)
-          user_errors = response["data"]["moduleUploadUrlGenerate"]["userErrors"]
-
-          raise Errors::GraphqlError, user_errors if user_errors.any?
-
-          data = response["data"]["moduleUploadUrlGenerate"]["details"]
-          { url: data["url"], headers: data["headers"], max_size: data["humanizedMaxSize"] }
-        end
-
-        private
-
-        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")
-
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Script
-  module Layers
-    module Infrastructure
-      class ScriptUploader
-        def initialize(script_service)
-          @script_service = script_service
-        end
-
-        def upload(script_content)
-          upload_details = @script_service.generate_module_upload_details
-          url = URI(upload_details[:url])
-
-          https = Net::HTTP.new(url.host, url.port)
-          https.use_ssl = true
-
-          request = Net::HTTP::Put.new(url)
-          request["Content-Type"] = "application/wasm"
-
-          upload_details[:headers].each do |header, value|
-            request[header] = value
-          end
-
-          request.body = script_content
-
-          response = https.request(request)
-          raise Errors::ScriptTooLargeError, upload_details[:max_size] if script_too_large?(response)
-          raise Errors::ScriptUploadError unless response.code == "200"
-
-          upload_details[:url]
-        end
-
-        private
-
-        def script_too_large?(response)
-          response.code == "400" && response.body.include?("EntityTooLarge")
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Script
-  module Layers
-    module Infrastructure
-      class ServiceLocator
-        def self.api_client(ctx:, api_key:)
-          if ENV["BYPASS_PARTNERS_PROXY"]
-            ApiClients::ScriptServiceApiClient.new(ctx, api_key)
-          else
-            ApiClients::PartnersProxyApiClient.new(ctx, api_key)
-          end
-        end
-
-        def self.script_service(ctx:, api_key:)
-          client = api_client(ctx: ctx, api_key: api_key)
-          ScriptService.new(client: client, api_key: api_key)
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Script
-  module Layers
-    module Infrastructure
-      class SparseCheckoutDetails
-        include SmartProperties
-        property! :repo, accepts: String
-        property! :branch, accepts: String
-        property! :path, accepts: String
-        property! :input_queries_enabled, accepts: [true, false]
-
-        def ==(other)
-          self.class == other.class &&
-            self.class.properties.all? { |name, _| self[name] == other[name] }
-        end
-
-        def setup(ctx)
-          ShopifyCLI::Git.sparse_checkout(repo, patterns_to_checkout, branch, ctx)
-        end
-
-        private
-
-        def patterns_to_checkout
-          paths = [path]
-          unless input_queries_enabled
-            paths << "!#{path}/#{ScriptProjectRepository::INPUT_QUERY_PATH}"
-            paths << "!#{path}/schema.graphql"
-          end
-          paths.join(" ")
-        end
-      end
-    end
-  end
-end