shopify-cli 0.9.0

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Script
+  module Layers
+    module Infrastructure
+      class AssemblyScriptTsConfig
+        TSCONFIG_FILE = "tsconfig.json"
+
+        attr_reader :config
+
+        def initialize(dir_to_write_in:)
+          @dir_to_write_in = dir_to_write_in
+          @config = {}
+        end
+
+        def with_extends_assemblyscript_config(relative_path_to_node_modules:)
+          relative_path = Pathname.new(relative_path_to_node_modules).relative_path_from(@dir_to_write_in)
+          @config[:extends] = "#{relative_path}/node_modules/assemblyscript/std/assembly.json"
+          self
+        end
+
+        def with_module_resolution_paths(paths:)
+          @config[:compilerOptions] = {
+            baseUrl: ".",
+            paths: paths,
+          }
+          self
+        end
+
+        def write
+          File.write("#{@dir_to_write_in}/#{TSCONFIG_FILE}", JSON.pretty_generate(@config))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class AssemblyScriptWasmBuilder
+        BYTECODE_FILE = "%{name}.wasm"
+        SCRIPT_SDK_BUILD = "npx --no-install shopify-scripts-build --src=../%{source} --binary=#{BYTECODE_FILE} "\
+                           "-- --lib=../node_modules --validate --optimize"
+
+        attr_reader :script
+
+        def initialize(script)
+          @script = script
+        end
+
+        def build
+          compile
+          bytecode
+        end
+
+        def compiled_type
+          "wasm"
+        end
+
+        private
+
+        def compile
+          out, status = CLI::Kit::System.capture2e(format(SCRIPT_SDK_BUILD, source: script.id, name: script.name))
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+        end
+
+        def bytecode
+          File.read(format(BYTECODE_FILE, name: script.name))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class NoopDependencyManager
+        def initialize(_ctx, language, _extension_point, script_name)
+          @language = language
+          @script_name = script_name
+        end
+
+        def bootstrap
+        end
+
+        def installed?
+        end
+
+        def install
+        end
+      end
+
+      class DependencyManager
+        DEP_MANAGER = {
+          "ts" => AssemblyScriptDependencyManager,
+          "js" => NoopDependencyManager,
+          "json" => NoopDependencyManager,
+        }
+
+        def self.for(ctx, language, extension_point, script_name)
+          raise Errors::DependencyError, language unless DEP_MANAGER[language]
+          DEP_MANAGER[language].new(ctx, language, extension_point, script_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      module Errors
+        class AppNotInstalledError < ScriptProjectError; end
+        class AppScriptUndefinedError < ScriptProjectError; end
+        class BuilderNotFoundError < ScriptProjectError; end
+        class BuildError < ScriptProjectError; end
+        class DependencyError < ScriptProjectError; end
+        class DependencyInstallError < ScriptProjectError; end
+        class ForbiddenError < ScriptProjectError; end
+        class GraphqlError < ScriptProjectError
+          attr_reader :errors
+          def initialize(errors)
+            @errors = errors
+            super("GraphQL failed with errors: #{errors}")
+          end
+        end
+        class ScriptRepushError < ScriptProjectError
+          attr_reader :api_key
+          def initialize(api_key)
+            @api_key = api_key
+          end
+        end
+        class ScriptServiceUserError < ScriptProjectError
+          def initialize(query_name, errors)
+            super("Failed performing #{query_name}. Errors: #{errors}.")
+          end
+        end
+        class ShopAuthenticationError < ScriptProjectError; end
+        class ShopScriptConflictError < ScriptProjectError; end
+        class ShopScriptUndefinedError < ScriptProjectError; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class ExtensionPointRepository
+        def get_extension_point(type)
+          Domain::ExtensionPoint.new(type, fetch_extension_point(type))
+        end
+
+        def extension_point_types
+          extension_points.keys
+        end
+
+        private
+
+        def fetch_extension_point(type)
+          raise Domain::Errors::InvalidExtensionPointError, type unless extension_points[type]
+          extension_points[type]
+        end
+
+        def extension_points
+          @extension_points ||= begin
+            require 'yaml'
+            YAML.load_file(Project.project_filepath('config/extension_points.yml'))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class PushPackageRepository
+        def create_push_package(script, script_content, compiled_type)
+          build_file_path = file_path(script.name, compiled_type)
+          write_to_path(build_file_path, script_content)
+
+          Domain::PushPackage.new(
+            build_file_path,
+            script,
+            script_content,
+            compiled_type,
+          )
+        end
+
+        def get_push_package(script, compiled_type)
+          build_file_path = file_path(script.name, compiled_type)
+
+          raise Domain::PushPackageNotFoundError unless File.exist?(build_file_path)
+
+          script_content = File.read(build_file_path)
+
+          Domain::PushPackage.new(
+            build_file_path,
+            script,
+            script_content,
+            compiled_type,
+          )
+        end
+
+        private
+
+        def write_to_path(path, content)
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, content)
+        end
+
+        def file_path(script_name, compiled_type)
+          "#{ScriptProject.current.directory}/build/#{script_name}.#{compiled_type}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class NoopBuilder
+        def initialize(script)
+          @script = script
+        end
+
+        def build
+          File.read(@script.filename)
+        end
+
+        def compiled_type
+          @script.language
+        end
+      end
+
+      class ScriptBuilder
+        COMPILERS = {
+          "ts" => Infrastructure::AssemblyScriptWasmBuilder,
+          "js" => Infrastructure::NoopBuilder,
+          "json" => Infrastructure::NoopBuilder,
+        }
+
+        def self.for(script)
+          raise Errors::BuilderNotFoundError unless COMPILERS[script.language]
+          COMPILERS[script.language].new(script)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class ScriptRepository
+        BOOTSTRAP_SRC = "npx --no-install shopify-scripts-bootstrap src %{src_base}"
+
+        def create_script(language, extension_point, script_name)
+          FileUtils.mkdir_p(src_base)
+          out, status = CLI::Kit::System.capture2e(format(BOOTSTRAP_SRC, src_base: src_base))
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+
+          write_tsconfig if language == "ts"
+
+          Domain::Script.new(
+            script_id(language),
+            script_name,
+            extension_point.type,
+            language
+          )
+        end
+
+        def get_script(language, extension_point_type, script_name)
+          source_file_path = src_code_file(language)
+          unless File.exist?(source_file_path)
+            raise Domain::Errors::ScriptNotFoundError.new(extension_point_type, source_file_path)
+          end
+
+          Domain::Script.new(script_id(language), script_name, extension_point_type, language)
+        end
+
+        def with_temp_build_context
+          prev_dir = Dir.pwd
+          temp_dir = "#{project_base}/temp"
+          FileUtils.mkdir_p(temp_dir)
+          Dir.chdir(temp_dir)
+          FileUtils.cp_r("#{src_base}/.", ".")
+          yield
+        ensure
+          Dir.chdir(prev_dir)
+          FileUtils.rm_rf(temp_dir)
+        end
+
+        def relative_path_to_src
+          "src"
+        end
+
+        private
+
+        def write_sdk(extension_point_type, language, sdk_types)
+          return unless language == "ts"
+          File.write(sdk_types_file(extension_point_type, language), sdk_types)
+        end
+
+        def write_tsconfig
+          AssemblyScriptTsConfig
+            .new(dir_to_write_in: relative_path_to_src)
+            .with_extends_assemblyscript_config(relative_path_to_node_modules: ".")
+            .write
+        end
+
+        def project_base
+          ScriptProject.current.directory
+        end
+
+        def src_base
+          "#{project_base}/#{relative_path_to_src}"
+        end
+
+        def script_id(language)
+          "#{relative_path_to_src}/#{file_name(language)}"
+        end
+
+        def src_code_file(language)
+          "#{src_base}/#{file_name(language)}"
+        end
+
+        def file_name(language)
+          "script.#{language}"
+        end
+
+        def sdk_types_file(extension_point_type, language)
+          "#{src_base}/#{extension_point_type}.#{language}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+
+module Script
+  module Layers
+    module Infrastructure
+      class ScriptService
+        include SmartProperties
+        property! :ctx, accepts: ShopifyCli::Context
+
+        def push(
+          extension_point_type:,
+          script_name:,
+          script_content:,
+          compiled_type:,
+          api_key: nil,
+          force: false
+        )
+          query_name = "app_script_update_or_create"
+          variables = {
+            extensionPointName: extension_point_type.upcase,
+            title: script_name,
+            sourceCode: Base64.encode64(script_content),
+            language: compiled_type,
+            force: force,
+          }
+          resp_hash = script_service_request(query_name: query_name, api_key: api_key, variables: variables)
+          user_errors = resp_hash["data"]["appScriptUpdateOrCreate"]["userErrors"]
+
+          return resp_hash if user_errors.empty?
+
+          if user_errors.any? { |e| e['tag'] == 'already_exists_error' }
+            raise Errors::ScriptRepushError, api_key
+          else
+            raise Errors::ScriptServiceUserError.new(query_name, user_errors.to_s)
+          end
+        end
+
+        def enable(api_key:, shop_domain:, configuration:, extension_point_type:, title:)
+          query_name = "shop_script_update_or_create"
+          variables = {
+            extensionPointName: extension_point_type.upcase,
+            configuration: configuration,
+            title: title,
+          }
+
+          resp_hash = script_service_request(
+            query_name: query_name,
+            api_key: api_key,
+            shop_domain: shop_domain,
+            variables: variables,
+          )
+          user_errors = resp_hash["data"]["shopScriptUpdateOrCreate"]["userErrors"]
+
+          return resp_hash if user_errors.empty?
+
+          if user_errors.any? { |e| e['tag'] == 'app_script_not_found' }
+            raise Errors::AppScriptUndefinedError, api_key
+          elsif user_errors.any? { |e| e['tag'] == 'shop_script_conflict' }
+            raise Errors::ShopScriptConflictError
+          else
+            raise Errors::ScriptServiceUserError.new(query_name, user_errors.to_s)
+          end
+        end
+
+        def disable(api_key:, shop_domain:, extension_point_type:)
+          query_name = "shop_script_delete"
+          variables = {
+            extensionPointName: extension_point_type.upcase,
+          }
+
+          resp_hash = script_service_request(
+            query_name: query_name,
+            api_key: api_key,
+            shop_domain: shop_domain,
+            variables: variables,
+          )
+          user_errors = resp_hash["data"]["shopScriptDelete"]["userErrors"]
+          return resp_hash if user_errors.empty?
+
+          if user_errors.any? { |e| e['tag'] == 'shop_script_not_found' }
+            raise Errors::ShopScriptUndefinedError, api_key
+          else
+            raise Errors::ScriptServiceUserError.new(query_name, user_errors.to_s)
+          end
+        end
+
+        private
+
+        class ScriptServiceAPI < ShopifyCli::API
+          property(:api_key, accepts: String)
+          property(:shop_id, accepts: Integer)
+
+          def self.query(ctx, query_name, api_key: nil, shop_domain: nil, variables: {})
+            api_client(ctx, api_key, shop_domain).query(query_name, variables: variables)
+          end
+
+          def self.api_client(ctx, api_key, shop_domain)
+            new(
+              ctx: ctx,
+              url: 'https://script-service.myshopify.io/graphql',
+              token: '',
+              api_key: api_key,
+              shop_id: shop_domain&.to_i
+            )
+          end
+
+          def auth_headers(*)
+            tokens = { "APP_KEY" => api_key, "SHOP_ID" => shop_id }.compact.to_json
+            { "X-Shopify-Authenticated-Tokens" => tokens }
+          end
+        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 ENV["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 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
+
+        def raise_if_graphql_failed(response)
+          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'].map { |e| e['message'] }
+          end
+        end
+
+        def error_code(errors)
+          errors.map do |e|
+            code = e.dig('extensions', 'code')
+            return code if code
+          end
+        end
+      end
+    end
+  end
+end