shopify-cli 1.5.0 → 1.9.0

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

@@ -5,14 +5,14 @@ module Script
     module Infrastructure
       class AssemblyScriptTaskRunner
         BYTECODE_FILE = "build/%{name}.wasm"
+        METADATA_FILE = "build/metadata.json"
         SCRIPT_SDK_BUILD = "npm run build"
 
-        attr_reader :ctx, :script_name, :script_source_file
+        attr_reader :ctx, :script_name
 
-        def initialize(ctx, script_name, script_source_file)
+        def initialize(ctx, script_name)
           @ctx = ctx
           @script_name = script_name
-          @script_source_file = script_source_file
         end
 
         def build
@@ -27,15 +27,23 @@ module Script
         def install_dependencies
           check_node_version!
 
-          output, status = ctx.capture2e("npm", "install", "--no-audit", "--no-optional", "--loglevel error")
+          output, status = ctx.capture2e("npm install --no-audit --no-optional --legacy-peer-deps --loglevel error")
           raise Errors::DependencyInstallError, output unless status.success?
         end
 
         def dependencies_installed?
           # Assuming if node_modules folder exist at root of script folder, all deps are installed
-          return false unless ctx.dir_exist?("node_modules")
-          check_if_ep_dependencies_up_to_date!
-          true
+          ctx.dir_exist?("node_modules")
+        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
@@ -44,12 +52,12 @@ module Script
           output, status = @ctx.capture2e("node", "--version")
           raise Errors::DependencyInstallError, output unless status.success?
 
-          require 'semantic/semantic'
+          require "semantic/semantic"
           version = ::Semantic::Version.new(output[1..-1])
           unless version >= ::Semantic::Version.new(AssemblyScriptProjectCreator::MIN_NODE_VERSION)
             raise Errors::DependencyInstallError,
-                  "Node version must be >= v#{AssemblyScriptProjectCreator::MIN_NODE_VERSION}. "\
-                  "Current version: #{output.strip}."
+              "Node version must be >= v#{AssemblyScriptProjectCreator::MIN_NODE_VERSION}. "\
+              "Current version: #{output.strip}."
           end
         end
 
@@ -61,8 +69,8 @@ module Script
         end
 
         def check_compilation_dependencies!
-          pkg = JSON.parse(File.read('package.json'))
-          build_script = pkg.dig('scripts', 'build')
+          pkg = JSON.parse(File.read("package.json"))
+          build_script = pkg.dig("scripts", "build")
 
           raise Errors::BuildScriptNotFoundError,
             "Build script not found" if build_script.nil?
@@ -73,47 +81,14 @@ module Script
         end
 
         def bytecode
-          blob = format(BYTECODE_FILE, name: script_name)
-          raise Errors::WebAssemblyBinaryNotFoundError unless @ctx.file_exist?(blob)
+          filename = format(BYTECODE_FILE, name: script_name)
+          raise Errors::WebAssemblyBinaryNotFoundError unless ctx.file_exist?(filename)
 
-          contents = File.read(blob)
-          @ctx.rm(blob)
+          contents = ctx.binread(filename)
+          ctx.rm(filename)
 
           contents
         end
-
-        def check_if_ep_dependencies_up_to_date!
-          return true if ENV['SHOPIFY_CLI_SCRIPTS_IGNORE_OUTDATED']
-
-          # ignore exit code since it will not be 0 unless every package is up to date which they probably won't be
-          out, _ = ctx.capture2e("npm", "outdated", "--json", "--depth", "0")
-          parsed_outdated_check = JSON.parse(out)
-          outdated_ep_packages = parsed_outdated_check
-            .select { |package_name, _| package_name.start_with?('@shopify/extension-point-as-') }
-            .select { |_, version_info| !package_is_up_to_date?(version_info) }
-            .keys
-          raise Errors::PackagesOutdatedError.new(outdated_ep_packages),
-            "NPM packages out of date: #{outdated_ep_packages.join(', ')}" unless outdated_ep_packages.empty?
-        end
-
-        def package_is_up_to_date?(version_info)
-          require 'semantic/semantic'
-          current_version = version_info['current']
-          latest_version = version_info['latest']
-
-          # making an assumption that the script developer knows what they're doing if they're not referencing a
-          # semver version
-          begin
-            current_version = ::Semantic::Version.new(current_version)
-            latest_version = ::Semantic::Version.new(latest_version)
-          rescue ArgumentError
-            return true
-          end
-
-          return false if current_version.major < latest_version.major
-          return false if latest_version.major == 0 && current_version.minor < latest_version.minor
-          true
-        end
       end
     end
   end

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

@@ -5,12 +5,41 @@ module Script
     module Infrastructure
       module Errors
         class AppNotInstalledError < ScriptProjectError; end
-        class AppScriptNotPushedError < ScriptProjectError; end
-        class AppScriptUndefinedError < ScriptProjectError; end
         class BuildError < ScriptProjectError; end
+        class ConfigUiSyntaxError < ScriptProjectError; end
+
+        class ConfigUiMissingKeysError < ScriptProjectError
+          attr_reader :filename, :missing_keys
+          def initialize(filename, missing_keys)
+            super()
+            @filename = filename
+            @missing_keys = missing_keys
+          end
+        end
+
+        class ConfigUiFieldsMissingKeysError < ScriptProjectError
+          attr_reader :filename, :missing_keys
+          def initialize(filename, missing_keys)
+            super()
+            @filename = filename
+            @missing_keys = missing_keys
+          end
+        end
+
         class DependencyInstallError < ScriptProjectError; end
+        class DeprecatedEPError < ScriptProjectError; end
         class EmptyResponseError < ScriptProjectError; end
         class ForbiddenError < ScriptProjectError; end
+        class InvalidContextError < ScriptProjectError; end
+
+        class InvalidLanguageError < ScriptProjectError
+          attr_reader :language, :extension_point_type
+          def initialize(language, extension_point_type)
+            super()
+            @language = language
+            @extension_point_type = extension_point_type
+          end
+        end
 
         class GraphqlError < ScriptProjectError
           attr_reader :errors
@@ -30,25 +59,9 @@ module Script
           end
         end
 
-        class ScriptServiceUserError < ScriptProjectError
-          def initialize(query_name, errors)
-            super("Failed performing #{query_name}. Errors: #{errors}.")
-          end
-        end
-
+        class ScriptProjectAlreadyExistsError < ScriptProjectError; end
         class ShopAuthenticationError < ScriptProjectError; end
-        class ShopScriptConflictError < ScriptProjectError; end
-        class ShopScriptUndefinedError < ScriptProjectError; end
         class TaskRunnerNotFoundError < ScriptProjectError; end
-
-        class PackagesOutdatedError < ScriptProjectError
-          attr_reader :outdated_packages
-          def initialize(outdated_packages)
-            super("EP packages are outdated and need to be updated: #{outdated_packages.join(', ')}")
-            @outdated_packages = outdated_packages
-          end
-        end
-
         class BuildScriptNotFoundError < ScriptProjectError; end
         class InvalidBuildScriptError < ScriptProjectError; end
 

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

@@ -8,21 +8,27 @@ module Script
           Domain::ExtensionPoint.new(type, fetch_extension_point(type))
         end
 
+        def extension_points
+          extension_point_configs.map do |type, extension_point_config|
+            Domain::ExtensionPoint.new(type, extension_point_config)
+          end
+        end
+
         def extension_point_types
-          extension_points.keys
+          extension_point_configs.keys
         end
 
         private
 
         def fetch_extension_point(type)
-          raise Domain::Errors::InvalidExtensionPointError, type unless extension_points[type]
-          extension_points[type]
+          raise Domain::Errors::InvalidExtensionPointError, type unless extension_point_configs[type]
+          extension_point_configs[type]
         end
 
-        def extension_points
+        def extension_point_configs
           @extension_points ||= begin
-            require 'yaml'
-            YAML.load_file(Project.project_filepath('config/extension_points.yml'))
+            require "yaml"
+            YAML.load_file(Project.project_filepath("config/extension_points.yml"))
           end
         end
       end

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

@@ -5,7 +5,8 @@ module Script
     module Infrastructure
       class ProjectCreator
         PROJECT_CREATORS = {
-          "ts" => Infrastructure::AssemblyScriptProjectCreator,
+          "assemblyscript" => Infrastructure::AssemblyScriptProjectCreator,
+          "rust" => Infrastructure::RustProjectCreator,
         }
 
         def self.for(ctx, language, extension_point, script_name, path_to_project)

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

@@ -7,30 +7,35 @@ module Script
         include SmartProperties
         property! :ctx, accepts: ShopifyCli::Context
 
-        def create_push_package(script, script_content, compiled_type)
-          build_file_path = file_path(script.name, compiled_type)
+        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)
           write_to_path(build_file_path, script_content)
 
           Domain::PushPackage.new(
-            build_file_path,
-            script,
-            script_content,
-            compiled_type,
+            id: build_file_path,
+            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,
           )
         end
 
-        def get_push_package(script, compiled_type)
-          build_file_path = file_path(script.name, compiled_type)
-
+        def get_push_package(script_project:, compiled_type:, metadata:)
+          build_file_path = file_path(script_project.id, script_project.script_name, compiled_type)
           raise Domain::PushPackageNotFoundError unless ctx.file_exist?(build_file_path)
 
-          script_content = File.read(build_file_path)
+          script_content = ctx.binread(build_file_path)
 
           Domain::PushPackage.new(
-            build_file_path,
-            script,
-            script_content,
-            compiled_type,
+            id: build_file_path,
+            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,
           )
         end
 
@@ -38,11 +43,11 @@ module Script
 
         def write_to_path(path, content)
           ctx.mkdir_p(File.dirname(path))
-          ctx.write(path, content)
+          ctx.binwrite(path, content)
         end
 
-        def file_path(script_name, compiled_type)
-          "#{ScriptProject.current.directory}/build/#{script_name}.#{compiled_type}"
+        def file_path(path_to_script, script_name, compiled_type)
+          "#{path_to_script}/build/#{script_name}.#{compiled_type}"
         end
       end
     end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      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 git_init
+          out, status = ctx.capture2e("git init")
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+        end
+
+        def setup_remote
+          repo = extension_point.sdks.rust.package
+          out, status = ctx.capture2e("git remote add -f origin #{repo}")
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+        end
+
+        def setup_sparse_checkout
+          type = extension_point.type
+          out, status = ctx.capture2e("git config core.sparsecheckout true")
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+          out, status = ctx.capture2e("echo #{type}/#{SAMPLE_PATH} >> .git/info/sparse-checkout")
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+        end
+
+        def pull
+          out, status = ctx.capture2e("git pull origin #{ORIGIN_BRANCH}")
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+        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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Script
+  module Layers
+    module Infrastructure
+      class RustTaskRunner
+        attr_reader :ctx, :script_name
+
+        BUILD_TARGET = "wasm32-unknown-unknown"
+        METADATA_FILE = "build/metadata.json"
+
+        def initialize(ctx, script_name)
+          @ctx = ctx
+          @script_name = script_name
+        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
+          out, status = ctx.capture2e("cargo build --target=#{BUILD_TARGET} --release")
+          raise Domain::Errors::ServiceFailureError, out unless status.success?
+        end
+
+        def bytecode
+          binary_name = "#{script_name}.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

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class ScriptProjectRepository
+        include SmartProperties
+        property! :ctx, accepts: ShopifyCli::Context
+
+        DEFAULT_CONFIG_UI_FILENAME = "config-ui.yml"
+
+        def create(script_name:, extension_point_type:, language:, no_config_ui:)
+          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
+          )
+
+          Domain::ScriptProject.new(
+            id: ctx.root,
+            env: project.env,
+            script_name: script_name,
+            extension_point_type: extension_point_type,
+            language: language,
+            config_ui: config_ui_file
+          )
+        end
+
+        def get
+          extension_point_type = project_config_value!("extension_point_type")
+          script_name = project_config_value!("script_name")
+          config_ui_file = project_config_value("config_ui_file")
+          language = project_config_value("language")&.downcase || default_language
+
+          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
+          )
+        end
+
+        private
+
+        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
+          ShopifyCli::Project.current
+        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
+
+        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
+
+        class ConfigUiRepository
+          include SmartProperties
+          property! :ctx, accepts: ShopifyCli::Context
+
+          def create(filename, content)
+            File.write(filename, content)
+
+            Domain::ConfigUi.new(
+              filename: filename,
+              content: content,
+            )
+          end
+
+          def get(filename)
+            return nil unless filename
+
+            path = File.join(ctx.root, filename)
+            raise Domain::Errors::MissingSpecifiedConfigUiDefinitionError, filename unless File.exist?(path)
+
+            content = File.read(path)
+            raise Domain::Errors::InvalidConfigUiDefinitionError, filename unless valid_config_ui?(content)
+
+            Domain::ConfigUi.new(
+              filename: filename,
+              content: content,
+            )
+          end
+
+          private
+
+          def valid_config_ui?(raw_yaml)
+            require "yaml" # takes 20ms, so deferred as late as possible.
+            YAML.safe_load(raw_yaml)
+            true
+          rescue Psych::SyntaxError
+            false
+          end
+        end
+      end
+    end
+  end
+end