shopify-cli 1.4.1 → 1.8.0

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

@@ -4,16 +4,15 @@ module Script
   module Layers
     module Infrastructure
       class AssemblyScriptTaskRunner
-        BYTECODE_FILE = "%{name}.wasm"
-        SCRIPT_SDK_BUILD = "npx --no-install shopify-scripts-build --src=../%{source} --binary=#{BYTECODE_FILE} "\
-                           "-- --lib=../node_modules --optimize --use Date="
+        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
@@ -28,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
@@ -45,53 +52,42 @@ 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("12.16.0")
-            raise Errors::DependencyInstallError, "Node version must be >= v12.16.0. Current version: #{output.strip}."
+          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}."
           end
         end
 
         def compile
-          out, status = ctx.capture2e(format(SCRIPT_SDK_BUILD, source: script_source_file, name: script_name))
+          check_compilation_dependencies!
+
+          out, status = ctx.capture2e(SCRIPT_SDK_BUILD)
           raise Domain::Errors::ServiceFailureError, out unless status.success?
         end
 
-        def bytecode
-          File.read(format(BYTECODE_FILE, name: script_name))
-        end
+        def check_compilation_dependencies!
+          pkg = JSON.parse(File.read("package.json"))
+          build_script = pkg.dig("scripts", "build")
 
-        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
+          raise Errors::BuildScriptNotFoundError,
+            "Build script not found" if build_script.nil?
 
-        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
+          unless build_script.start_with?("shopify-scripts")
+            raise Errors::InvalidBuildScriptError, "Invalid build script"
           end
+        end
+
+        def bytecode
+          blob = format(BYTECODE_FILE, name: script_name)
+          raise Errors::WebAssemblyBinaryNotFoundError unless @ctx.file_exist?(blob)
+
+          contents = File.read(blob)
+          @ctx.rm(blob)
 
-          return false if current_version.major < latest_version.major
-          return false if latest_version.major == 0 && current_version.minor < latest_version.minor
-          true
+          contents
         end
       end
     end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class ConfigUiRepository
+        include SmartProperties
+        property! :ctx, accepts: ShopifyCli::Context
+
+        def create_config_ui(filename, content)
+          File.write(filename, content)
+
+          Domain::ConfigUi.new(
+            filename: filename,
+            content: content,
+          )
+        end
+
+        def get_config_ui(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

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

@@ -8,8 +8,30 @@ module Script
         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 EmptyResponseError < ScriptProjectError; end
         class ForbiddenError < ScriptProjectError; end
+
         class GraphqlError < ScriptProjectError
           attr_reader :errors
           def initialize(errors)
@@ -17,7 +39,9 @@ module Script
             super("GraphQL failed with errors: #{errors}")
           end
         end
+
         class ProjectCreatorNotFoundError < ScriptProjectError; end
+
         class ScriptRepushError < ScriptProjectError
           attr_reader :api_key
           def initialize(api_key)
@@ -25,20 +49,23 @@ module Script
             @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
         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
+        class BuildScriptNotFoundError < ScriptProjectError; end
+        class InvalidBuildScriptError < ScriptProjectError; end
+
+        class WebAssemblyBinaryNotFoundError < ScriptProjectError
+          def initialize
+            super("WebAssembly binary not found")
           end
         end
       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,37 @@ 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:, config_ui:)
+          build_file_path = file_path(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,
+            description: script_project.description,
+            script_content: script_content,
+            compiled_type: compiled_type,
+            metadata: metadata,
+            config_ui: 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:, config_ui:)
+          build_file_path = file_path(script_project.script_name, compiled_type)
           raise Domain::PushPackageNotFoundError unless ctx.file_exist?(build_file_path)
 
           script_content = File.read(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,
+            description: script_project.description,
+            script_content: script_content,
+            compiled_type: compiled_type,
+            metadata: metadata,
+            config_ui: config_ui,
           )
         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)
+
+          File.read(binary_path)
+        end
+      end
+    end
+  end
+end