shopify-cli 1.10.0 → 1.14.0

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      module Languages
+        class ProjectCreator
+          PROJECT_CREATORS = {
+            "assemblyscript" => AssemblyScriptProjectCreator,
+            "rust" => RustProjectCreator,
+          }
+
+          def self.for(ctx, language, extension_point, script_name, path_to_project)
+            raise Errors::ProjectCreatorNotFoundError unless PROJECT_CREATORS[language]
+            PROJECT_CREATORS[language].new(
+              ctx: ctx,
+              extension_point: extension_point,
+              script_name: script_name,
+              path_to_project: path_to_project
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      module Languages
+        class RustProjectCreator
+          include SmartProperties
+          property! :ctx, accepts: ShopifyCli::Context
+          property! :extension_point, accepts: Domain::ExtensionPoint
+          property! :script_name, accepts: String
+          property! :path_to_project, accepts: String
+
+          ORIGIN_BRANCH = "main"
+          SAMPLE_PATH = "default"
+
+          def setup_dependencies
+            git_init
+            setup_remote
+            setup_sparse_checkout
+            pull
+            clean
+            set_script_name
+          end
+
+          def bootstrap
+          end
+
+          private
+
+          def command_runner
+            @command_runner ||= CommandRunner.new(ctx: ctx)
+          end
+
+          def git_init
+            command_runner.call("git init")
+          end
+
+          def setup_remote
+            repo = extension_point.sdks.rust.package
+            command_runner.call("git remote add -f origin #{repo}")
+          end
+
+          def setup_sparse_checkout
+            type = extension_point.type
+            command_runner.call("git config core.sparsecheckout true")
+            command_runner.call("echo #{type}/#{SAMPLE_PATH} >> .git/info/sparse-checkout")
+          end
+
+          def pull
+            command_runner.call("git pull origin #{ORIGIN_BRANCH}")
+          end
+
+          def clean
+            type = extension_point.type
+            ctx.rm_rf(".git")
+            source = File.join(path_to_project, File.join(type, SAMPLE_PATH))
+            FileUtils.copy_entry(source, path_to_project)
+            ctx.rm_rf(type)
+          end
+
+          def set_script_name
+            config_file = "Cargo.toml"
+            upstream_name = "#{extension_point.type.gsub("_", "-")}-default"
+            contents = File.read(config_file)
+            new_contents = contents.sub(upstream_name, script_name)
+            File.write(config_file, new_contents)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Script
+  module Layers
+    module Infrastructure
+      module Languages
+        class RustTaskRunner
+          attr_reader :ctx
+
+          BUILD_TARGET = "wasm32-unknown-unknown"
+          METADATA_FILE = "build/metadata.json"
+          CARGO_BUILD_CMD = "cargo build --target=#{BUILD_TARGET} --release"
+
+          def initialize(ctx, _)
+            @ctx = ctx
+          end
+
+          def dependencies_installed?
+            true
+          end
+
+          def install_dependencies
+          end
+
+          def build
+            compile
+            bytecode
+          end
+
+          def compiled_type
+            "wasm"
+          end
+
+          def metadata
+            unless @ctx.file_exist?(METADATA_FILE)
+              msg = @ctx.message("script.error.metadata_not_found_cause", METADATA_FILE)
+              raise Domain::Errors::MetadataNotFoundError, msg
+            end
+
+            raw_contents = File.read(METADATA_FILE)
+            Domain::Metadata.create_from_json(@ctx, raw_contents)
+          end
+
+          private
+
+          def compile
+            CommandRunner.new(ctx: ctx).call(CARGO_BUILD_CMD)
+          end
+
+          def bytecode
+            binary_name = "script.wasm"
+            binary_path = "target/#{BUILD_TARGET}/release/#{binary_name}"
+            raise Errors::WebAssemblyBinaryNotFoundError unless ctx.file_exist?(binary_path)
+
+            ctx.binread(binary_path)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      module Languages
+        class TaskRunner
+          TASK_RUNNERS = {
+            "assemblyscript" => AssemblyScriptTaskRunner,
+            "rust" => RustTaskRunner,
+          }
+
+          def self.for(ctx, language, script_name)
+            raise Errors::TaskRunnerNotFoundError unless TASK_RUNNERS[language]
+            TASK_RUNNERS[language].new(ctx, script_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,23 +8,22 @@ module Script
         property! :ctx, accepts: ShopifyCli::Context
 
         def create_push_package(script_project:, script_content:, compiled_type:, metadata:)
-          build_file_path = file_path(script_project.id, script_project.script_name, compiled_type)
+          build_file_path = file_path(script_project.id, compiled_type)
           write_to_path(build_file_path, script_content)
 
           Domain::PushPackage.new(
             id: build_file_path,
             uuid: script_project.uuid,
             extension_point_type: script_project.extension_point_type,
-            script_name: script_project.script_name,
             script_content: script_content,
             compiled_type: compiled_type,
             metadata: metadata,
-            config_ui: script_project.config_ui,
+            script_json: script_project.script_json,
           )
         end
 
         def get_push_package(script_project:, compiled_type:, metadata:)
-          build_file_path = file_path(script_project.id, script_project.script_name, compiled_type)
+          build_file_path = file_path(script_project.id, compiled_type)
           raise Domain::PushPackageNotFoundError unless ctx.file_exist?(build_file_path)
 
           script_content = ctx.binread(build_file_path)
@@ -32,11 +31,10 @@ module Script
             id: build_file_path,
             uuid: script_project.uuid,
             extension_point_type: script_project.extension_point_type,
-            script_name: script_project.script_name,
             script_content: script_content,
             compiled_type: compiled_type,
             metadata: metadata,
-            config_ui: script_project.config_ui,
+            script_json: script_project.script_json,
           )
         end
 
@@ -47,8 +45,8 @@ module Script
           ctx.binwrite(path, content)
         end
 
-        def file_path(path_to_script, script_name, compiled_type)
-          "#{path_to_script}/build/#{script_name}.#{compiled_type}"
+        def file_path(path_to_script, compiled_type)
+          "#{path_to_script}/build/script.#{compiled_type}"
         end
       end
     end

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

@@ -7,30 +7,19 @@ module Script
         include SmartProperties
         property! :ctx, accepts: ShopifyCli::Context
 
-        DEFAULT_CONFIG_UI_FILENAME = "config-ui.yml"
+        SCRIPT_JSON_FILENAME = "script.json"
         MUTABLE_ENV_VALUES = %i(uuid)
 
-        def create(script_name:, extension_point_type:, language:, no_config_ui:)
+        def create(script_name:, extension_point_type:, language:)
           validate_metadata!(extension_point_type, language)
 
-          optional_identifiers = {}
-          config_ui_file = nil
-
-          unless no_config_ui
-            optional_identifiers.merge!(config_ui_file: DEFAULT_CONFIG_UI_FILENAME)
-            config_ui_file = ConfigUiRepository
-              .new(ctx: ctx)
-              .create(DEFAULT_CONFIG_UI_FILENAME, default_config_ui_content(script_name))
-          end
-
           ShopifyCli::Project.write(
             ctx,
             project_type: :script,
             organization_id: nil,
             extension_point_type: extension_point_type,
             script_name: script_name,
-            language: language,
-            **optional_identifiers
+            language: language
           )
 
           Domain::ScriptProject.new(
@@ -38,23 +27,20 @@ module Script
             env: project.env,
             script_name: script_name,
             extension_point_type: extension_point_type,
-            language: language,
-            config_ui: config_ui_file
+            language: language
           )
         end
 
         def get
           validate_metadata!(extension_point_type, language)
 
-          config_ui = ConfigUiRepository.new(ctx: ctx).get(config_ui_file)
-
           Domain::ScriptProject.new(
             id: project.directory,
             env: project.env,
             script_name: script_name,
             extension_point_type: extension_point_type,
             language: language,
-            config_ui: config_ui
+            script_json: ScriptJsonRepository.new(ctx: ctx).get
           )
         end
 
@@ -72,7 +58,7 @@ module Script
             script_name: script_name,
             extension_point_type: extension_point_type,
             language: language,
-            config_ui: ConfigUiRepository.new(ctx: ctx).get(config_ui_file),
+            script_json: ScriptJsonRepository.new(ctx: ctx).get,
           )
         end
 
@@ -91,7 +77,22 @@ module Script
             script_name: script_name,
             extension_point_type: extension_point_type,
             language: language,
-            config_ui: ConfigUiRepository.new(ctx: ctx).get(config_ui_file),
+            script_json: ScriptJsonRepository.new(ctx: ctx).get,
+          )
+        end
+
+        def update_or_create_script_json(title:, configuration_ui: false)
+          script_json = ScriptJsonRepository
+            .new(ctx: ctx)
+            .update_or_create(title: title, configuration_ui: configuration_ui)
+
+          Domain::ScriptProject.new(
+            id: ctx.root,
+            env: project.env,
+            script_name: script_name,
+            extension_point_type: extension_point_type,
+            language: language,
+            script_json: script_json,
           )
         end
 
@@ -109,10 +110,6 @@ module Script
           project_config_value!("script_name")
         end
 
-        def config_ui_file
-          project_config_value("config_ui_file")
-        end
-
         def language
           project_config_value("language")&.downcase || default_language
         end
@@ -131,17 +128,6 @@ module Script
           @project ||= ShopifyCli::Project.current(force_reload: true)
         end
 
-        def default_config_ui_content(title)
-          require "yaml" # takes 20ms, so deferred as late as possible.
-          YAML.dump({
-            "version" => 1,
-            "inputMode" => "single",
-            "title" => title,
-            "description" => "",
-            "fields" => [],
-          })
-        end
-
         def default_language
           Domain::ExtensionPoint::ExtensionPointAssemblyScriptSDK.language
         end
@@ -154,41 +140,40 @@ module Script
           end
         end
 
-        class ConfigUiRepository
+        class ScriptJsonRepository
           include SmartProperties
           property! :ctx, accepts: ShopifyCli::Context
 
-          def create(filename, content)
-            File.write(filename, content)
-
-            Domain::ConfigUi.new(
-              filename: filename,
-              content: content,
-            )
+          def get
+            current_script_json || raise(Domain::Errors::NoScriptJsonFile)
           end
 
-          def get(filename)
-            return nil unless filename
-
-            path = File.join(ctx.root, filename)
-            raise Domain::Errors::MissingSpecifiedConfigUiDefinitionError, filename unless File.exist?(path)
+          def update_or_create(title:, configuration_ui:)
+            json = current_script_json&.content || {}
+            json["version"] ||= "1"
+            json["title"] = title
+            json["configurationUi"] = !!configuration_ui
 
-            content = File.read(path)
-            raise Domain::Errors::InvalidConfigUiDefinitionError, filename unless valid_config_ui?(content)
+            ctx.write(SCRIPT_JSON_FILENAME, JSON.pretty_generate(json))
 
-            Domain::ConfigUi.new(
-              filename: filename,
-              content: content,
-            )
+            Domain::ScriptJson.new(content: json)
           end
 
           private
 
-          def valid_config_ui?(raw_yaml)
-            require "yaml" # takes 20ms, so deferred as late as possible.
-            YAML.safe_load(raw_yaml)
+          def current_script_json
+            return nil unless ctx.file_exist?(SCRIPT_JSON_FILENAME)
+
+            content = ctx.read(SCRIPT_JSON_FILENAME)
+            raise Domain::Errors::InvalidScriptJsonDefinitionError unless valid_script_json?(content)
+
+            Domain::ScriptJson.new(content: JSON.parse(content))
+          end
+
+          def valid_script_json?(content)
+            JSON.parse(content)
             true
-          rescue Psych::SyntaxError
+          rescue JSON::ParserError
             false
           end
         end

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

@@ -13,26 +13,28 @@ module Script
         def push(
           uuid:,
           extension_point_type:,
-          script_name:,
           script_content:,
           compiled_type:,
           api_key: nil,
           force: false,
           metadata:,
-          config_ui:
+          script_json:
         )
           query_name = "app_script_update_or_create"
           variables = {
             uuid: uuid,
             extensionPointName: extension_point_type.upcase,
-            title: script_name,
-            configUi: config_ui&.content,
+            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,
           }
           resp_hash = script_service_request(query_name: query_name, api_key: api_key, variables: variables)
           user_errors = resp_hash["data"]["appScriptUpdateOrCreate"]["userErrors"]
@@ -40,17 +42,21 @@ module Script
           return resp_hash["data"]["appScriptUpdateOrCreate"]["appScript"]["uuid"] if user_errors.empty?
 
           if user_errors.any? { |e| e["tag"] == "already_exists_error" }
-            raise Errors::ScriptRepushError, api_key
-          elsif (e = user_errors.any? { |err| err["tag"] == "config_ui_syntax_error" })
-            raise Errors::ConfigUiSyntaxError, config_ui&.filename
-          elsif (e = user_errors.find { |err| err["tag"] == "config_ui_missing_keys_error" })
-            raise Errors::ConfigUiMissingKeysError.new(config_ui&.filename, e["message"])
-          elsif (e = user_errors.find { |err| err["tag"] == "config_ui_invalid_input_mode_error" })
-            raise Errors::ConfigUiInvalidInputModeError.new(config_ui&.filename, e["message"])
-          elsif (e = user_errors.find { |err| err["tag"] == "config_ui_fields_missing_keys_error" })
-            raise Errors::ConfigUiFieldsMissingKeysError.new(config_ui&.filename, e["message"])
-          elsif (e = user_errors.find { |err| err["tag"] == "config_ui_fields_invalid_type_error" })
-            raise Errors::ConfigUiFieldsInvalidTypeError.new(config_ui&.filename, e["message"])
+            raise Errors::ScriptRepushError, uuid
+          elsif (e = user_errors.any? { |err| err["tag"] == "configuration_syntax_error" })
+            raise Errors::ScriptJsonSyntaxError
+          elsif (e = user_errors.find { |err| err["tag"] == "configuration_definition_missing_keys_error" })
+            raise Errors::ScriptJsonMissingKeysError, e["message"]
+          elsif (e = user_errors.find { |err| err["tag"] == "configuration_definition_invalid_value_error" })
+            raise Errors::ScriptJsonInvalidValueError, e["message"]
+          elsif (e = user_errors.find do |err|
+                   err["tag"] == "configuration_definition_schema_field_missing_keys_error"
+                 end)
+            raise Errors::ScriptJsonFieldsMissingKeysError, e["message"]
+          elsif (e = user_errors.find do |err|
+                   err["tag"] == "configuration_definition_schema_field_invalid_value_error"
+                 end)
+            raise Errors::ScriptJsonFieldsInvalidValueError, e["message"]
           elsif user_errors.find { |err| %w(not_use_msgpack_error schema_version_argument_error).include?(err["tag"]) }
             raise Domain::Errors::MetadataValidationError
           else