shopify-cli 1.7.1 → 1.11.0

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

@@ -33,9 +33,7 @@ module Script
 
         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
@@ -65,9 +63,7 @@ module Script
 
         def compile
           check_compilation_dependencies!
-
-          out, status = ctx.capture2e(SCRIPT_SDK_BUILD)
-          raise Domain::Errors::ServiceFailureError, out unless status.success?
+          CommandRunner.new(ctx: ctx).call(SCRIPT_SDK_BUILD)
         end
 
         def check_compilation_dependencies!
@@ -83,47 +79,22 @@ module Script
         end
 
         def bytecode
-          blob = format(BYTECODE_FILE, name: script_name)
-          raise Errors::WebAssemblyBinaryNotFoundError unless @ctx.file_exist?(blob)
+          legacy_filename = format(BYTECODE_FILE, name: script_name)
+          filename = format(BYTECODE_FILE, name: "script")
+
+          bytecode_file = if ctx.file_exist?(filename)
+            filename
+          elsif ctx.file_exist?(legacy_filename)
+            legacy_filename
+          else
+            raise Errors::WebAssemblyBinaryNotFoundError
+          end
 
-          contents = File.read(blob)
-          @ctx.rm(blob)
+          contents = ctx.binread(bytecode_file)
+          ctx.rm(bytecode_file)
 
           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/command_runner.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Script
+  module Layers
+    module Infrastructure
+      class CommandRunner
+        include SmartProperties
+
+        property! :ctx, accepts: ShopifyCli::Context
+
+        def call(cmd)
+          out, status = ctx.capture2e(cmd)
+          raise Errors::SystemCallFailureError.new(out: out.chomp, cmd: cmd) unless status.success?
+          out
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,6 @@ 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
 
@@ -19,6 +17,15 @@ module Script
           end
         end
 
+        class ConfigUiInvalidInputModeError < ScriptProjectError
+          attr_reader :filename, :valid_input_modes
+          def initialize(filename, valid_input_modes)
+            super()
+            @filename = filename
+            @valid_input_modes = valid_input_modes
+          end
+        end
+
         class ConfigUiFieldsMissingKeysError < ScriptProjectError
           attr_reader :filename, :missing_keys
           def initialize(filename, missing_keys)
@@ -28,9 +35,29 @@ module Script
           end
         end
 
+        class ConfigUiFieldsInvalidTypeError < ScriptProjectError
+          attr_reader :filename, :valid_types
+          def initialize(filename, valid_types)
+            super()
+            @filename = filename
+            @valid_types = valid_types
+          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
@@ -42,33 +69,26 @@ module Script
 
         class ProjectCreatorNotFoundError < ScriptProjectError; end
 
-        class ScriptRepushError < ScriptProjectError
-          attr_reader :api_key
-          def initialize(api_key)
+        class SystemCallFailureError < ScriptProjectError
+          attr_reader :out, :cmd
+          def initialize(out:, cmd:)
             super()
-            @api_key = api_key
+            @out = out
+            @cmd = cmd
           end
         end
 
-        class ScriptServiceUserError < ScriptProjectError
-          def initialize(query_name, errors)
-            super("Failed performing #{query_name}. Errors: #{errors}.")
+        class ScriptRepushError < ScriptProjectError
+          attr_reader :uuid
+          def initialize(uuid)
+            super()
+            @uuid = uuid
           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/push_package_repository.rb

@@ -7,37 +7,36 @@ module Script
         include SmartProperties
         property! :ctx, accepts: ShopifyCli::Context
 
-        def create_push_package(script_project:, script_content:, compiled_type:, metadata:, config_ui:)
-          build_file_path = file_path(script_project.script_name, compiled_type)
+        def create_push_package(script_project:, script_content:, compiled_type:, metadata:)
+          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,
-            description: script_project.description,
             script_content: script_content,
             compiled_type: compiled_type,
             metadata: metadata,
-            config_ui: config_ui,
+            config_ui: script_project.config_ui,
           )
         end
 
-        def get_push_package(script_project:, compiled_type:, metadata:, config_ui:)
-          build_file_path = file_path(script_project.script_name, compiled_type)
+        def get_push_package(script_project:, compiled_type:, metadata:)
+          build_file_path = file_path(script_project.id, 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(
             id: build_file_path,
+            uuid: script_project.uuid,
             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,
+            config_ui: script_project.config_ui,
           )
         end
 
@@ -45,11 +44,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, compiled_type)
+          "#{path_to_script}/build/script.#{compiled_type}"
         end
       end
     end

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

@@ -27,28 +27,27 @@ module Script
 
         private
 
+        def command_runner
+          @command_runner ||= CommandRunner.new(ctx: ctx)
+        end
+
         def git_init
-          out, status = ctx.capture2e("git init")
-          raise Domain::Errors::ServiceFailureError, out unless status.success?
+          command_runner.call("git init")
         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?
+          command_runner.call("git remote add -f origin #{repo}")
         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?
+          command_runner.call("git config core.sparsecheckout true")
+          command_runner.call("echo #{type}/#{SAMPLE_PATH} >> .git/info/sparse-checkout")
         end
 
         def pull
-          out, status = ctx.capture2e("git pull origin #{ORIGIN_BRANCH}")
-          raise Domain::Errors::ServiceFailureError, out unless status.success?
+          command_runner.call("git pull origin #{ORIGIN_BRANCH}")
         end
 
         def clean

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

@@ -3,14 +3,14 @@ module Script
   module Layers
     module Infrastructure
       class RustTaskRunner
-        attr_reader :ctx, :script_name
+        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, script_name)
+        def initialize(ctx, _)
           @ctx = ctx
-          @script_name = script_name
         end
 
         def dependencies_installed?
@@ -42,16 +42,15 @@ module Script
         private
 
         def compile
-          out, status = ctx.capture2e("cargo build --target=#{BUILD_TARGET} --release")
-          raise Domain::Errors::ServiceFailureError, out unless status.success?
+          CommandRunner.new(ctx: ctx).call(CARGO_BUILD_CMD)
         end
 
         def bytecode
-          binary_name = "#{script_name}.wasm"
+          binary_name = "script.wasm"
           binary_path = "target/#{BUILD_TARGET}/release/#{binary_name}"
           raise Errors::WebAssemblyBinaryNotFoundError unless ctx.file_exist?(binary_path)
 
-          File.read(binary_path)
+          ctx.binread(binary_path)
         end
       end
     end

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

@@ -0,0 +1,172 @@
+# 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"
+        MUTABLE_ENV_VALUES = %i(uuid)
+
+        def create(script_name:, extension_point_type:, language:, no_config_ui:)
+          validate_metadata!(extension_point_type, language)
+
+          config_ui_file = nil
+          optional_identifiers = {}
+          optional_identifiers.merge!(config_ui_file: DEFAULT_CONFIG_UI_FILENAME) unless no_config_ui
+
+          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
+          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
+
+        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
+
+          Domain::ScriptProject.new(
+            id: ctx.root,
+            env: project.env,
+            script_name: script_name,
+            extension_point_type: extension_point_type,
+            language: language,
+            config_ui: ConfigUiRepository.new(ctx: ctx).get(config_ui_file),
+          )
+        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)
+
+          Domain::ScriptProject.new(
+            id: ctx.root,
+            env: project.env,
+            script_name: script_name,
+            extension_point_type: extension_point_type,
+            language: language,
+            config_ui: ConfigUiRepository.new(ctx: ctx).get(config_ui_file),
+          )
+        end
+
+        private
+
+        def capture_io(&block)
+          CLI::UI::StdoutRouter::Capture.new(&block).run
+        end
+
+        def extension_point_type
+          project_config_value!("extension_point_type")
+        end
+
+        def script_name
+          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
+
+        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
+          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 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