shopify-cli 1.4.1 → 1.8.0

data/lib/project_types/script/commands/disable.rb

@@ -12,13 +12,13 @@ module Script
           shop_domain: project.env[:shop],
           extension_point_type: project.extension_point_type
         )
-        @ctx.puts(@ctx.message('script.disable.script_disabled'))
+        @ctx.puts(@ctx.message("script.disable.script_disabled"))
       rescue StandardError => e
-        UI::ErrorHandler.pretty_print_and_raise(e, failed_op: @ctx.message('script.disable.error.operation_failed'))
+        UI::ErrorHandler.pretty_print_and_raise(e, failed_op: @ctx.message("script.disable.error.operation_failed"))
       end
 
       def self.help
-        ShopifyCli::Context.message('script.disable.help', ShopifyCli::TOOL_NAME)
+        ShopifyCli::Context.message("script.disable.help", ShopifyCli::TOOL_NAME)
       end
     end
   end

data/lib/project_types/script/commands/enable.rb

@@ -4,10 +4,10 @@ module Script
   module Commands
     class Enable < ShopifyCli::Command
       options do |parser, flags|
-        parser.on('--config_props=KEYVALUEPAIRS', Array) do |t|
-          flags[:config_props] = Hash[t.map { |s| s.split(':') }]
-        end
-        parser.on('--config_file=CONFIGFILEPATH') { |t| flags[:config_file] = t }
+        parser.on("--config_props=KEYVALUEPAIRS", Array) { |t| flags[:config_props] = t }
+        parser.on("--config-props=KEYVALUEPAIRS", Array) { |t| flags[:config_props] = t }
+        parser.on("--config_file=CONFIGFILEPATH") { |t| flags[:config_file] = t }
+        parser.on("--config-file=CONFIGFILEPATH") { |t| flags[:config_file] = t }
       end
 
       def call(_args, _name)
@@ -25,21 +25,21 @@ module Script
           title: project.script_name
         )
         @ctx.puts(@ctx.message(
-          'script.enable.script_enabled',
+          "script.enable.script_enabled",
           api_key: api_key,
           shop_domain: shop_domain,
           type: project.extension_point_type.capitalize,
           title: project.script_name
         ))
-        @ctx.puts(@ctx.message('script.enable.info'))
+        @ctx.puts(@ctx.message("script.enable.info"))
       rescue Errors::InvalidConfigYAMLError => e
         UI::ErrorHandler.pretty_print_and_raise(e)
       rescue StandardError => e
-        UI::ErrorHandler.pretty_print_and_raise(e, failed_op: @ctx.message('script.enable.error.operation_failed'))
+        UI::ErrorHandler.pretty_print_and_raise(e, failed_op: @ctx.message("script.enable.error.operation_failed"))
       end
 
       def self.help
-        ShopifyCli::Context.message('script.enable.help', ShopifyCli::TOOL_NAME)
+        ShopifyCli::Context.message("script.enable.help", ShopifyCli::TOOL_NAME)
       end
 
       private
@@ -47,7 +47,7 @@ module Script
       def acquire_configuration(config_file: nil, config_props: nil)
         properties = {}
         properties = YAML.load(File.read(config_file)) unless config_file.nil?
-        properties = properties.merge(config_props) unless config_props.nil?
+        properties = properties.merge(parse_config_props(config_props)) unless config_props.nil?
 
         configuration = { entries: [] }
         properties.each do |key, value|
@@ -61,6 +61,16 @@ module Script
         raise Errors::InvalidConfigYAMLError, options.flags[:config_file]
       end
 
+      def parse_config_props(config_props)
+        Hash[
+          config_props.map do |s|
+            args = s.split(":").map(&:strip)
+            raise Errors::InvalidConfigProps unless args.size == 2
+            args
+          end
+        ]
+      end
+
       # No slice pre Ruby 2.5 so roll our own
       def slice(hash, *keys)
         Hash[hash.to_a - hash.select { |key, _value| !keys.include?(key) }.to_a]

data/lib/project_types/script/commands/push.rb

@@ -4,31 +4,24 @@ module Script
   module Commands
     class Push < ShopifyCli::Command
       options do |parser, flags|
-        parser.on('--force') { |t| flags[:force] = t }
+        parser.on("--force") { |t| flags[:force] = t }
       end
 
       def call(_args, _name)
         ShopifyCli::Tasks::EnsureEnv.call(@ctx, required: [:api_key, :secret, :shop])
-        project = ScriptProject.current
-        api_key = project.env[:api_key]
-        return @ctx.puts(self.class.help) unless api_key &&
-          ScriptProject::SUPPORTED_LANGUAGES.include?(project.language)
-        Layers::Application::PushScript.call(
-          ctx: @ctx,
-          language: project.language,
-          extension_point_type: project.extension_point_type,
-          script_name: project.script_name,
-          source_file: project.source_file,
-          api_key: api_key,
-          force: options.flags.key?(:force)
-        )
-        @ctx.puts(@ctx.message('script.push.script_pushed', api_key: api_key))
+
+        api_key = ScriptProject.current.api_key
+        return @ctx.puts(self.class.help) unless api_key
+
+        Layers::Application::PushScript.call(ctx: @ctx, force: options.flags.key?(:force))
+        @ctx.puts(@ctx.message("script.push.script_pushed", api_key: api_key))
       rescue StandardError => e
-        UI::ErrorHandler.pretty_print_and_raise(e, failed_op: @ctx.message('script.push.error.operation_failed'))
+        msg = @ctx.message("script.push.error.operation_failed", api_key: ShopifyCli::Project.current.env.api_key)
+        UI::ErrorHandler.pretty_print_and_raise(e, failed_op: msg)
       end
 
       def self.help
-        ShopifyCli::Context.message('script.push.help', ShopifyCli::TOOL_NAME)
+        ShopifyCli::Context.message("script.push.help", ShopifyCli::TOOL_NAME)
       end
     end
   end

data/lib/project_types/script/config/extension_points.yml

@@ -1,24 +1,42 @@
 discount:
+  deprecated: true
   assemblyscript:
     package: "@shopify/extension-point-as-discount"
-    version: "^0.3.0"
-    sdk-version: "^7.0.0"
-    toolchain-version: "^1.1.0"
+    sdk-version: "^9.0.0"
+    toolchain-version: "^5.0.0"
 unit_limit_per_order:
   assemblyscript:
     package: "@shopify/extension-point-as-unit-limit-per-order"
-    version: "^0.2.0"
-    sdk-version: "^7.0.0"
-    toolchain-version: "^1.1.0"
+    sdk-version: "^9.0.0"
+    toolchain-version: "^5.0.0"
 payment_filter:
   assemblyscript:
     package: "@shopify/extension-point-as-payment-filter"
-    version: "^0.5.0"
-    sdk-version: "^7.0.0"
-    toolchain-version: "^1.1.0"
+    sdk-version: "^9.0.0"
+    toolchain-version: "^5.0.0"
+  rust:
+    beta: true
+    package: "https://github.com/Shopify/scripts-apis-rs"
 shipping_filter:
   assemblyscript:
     package: "@shopify/extension-point-as-shipping-filter"
-    version: "^0.3.0"
-    sdk-version: "^7.0.0"
-    toolchain-version: "^1.1.0"
+    sdk-version: "^9.0.0"
+    toolchain-version: "^5.0.0"
+tax_filter:
+  assemblyscript:
+    package: "@shopify/extension-point-as-tax-filter"
+    sdk-version: "^9.0.0"
+    toolchain-version: "^5.0.0"
+payment_methods:
+  domain: 'checkout'
+  assemblyscript:
+    package: "@shopify/scripts-checkout-apis"
+    toolchain-version: "^5.0.0"
+    sdk-version: "^9.0.0"
+shipping_methods:
+  domain: 'checkout'
+  assemblyscript:
+    package: "@shopify/scripts-checkout-apis"
+    sdk-version: "^9.0.0"
+    toolchain-version: "^5.0.0"
+

data/lib/project_types/script/errors.rb

@@ -4,8 +4,10 @@ module Script
   module Errors
     class InvalidContextError < ScriptProjectError; end
     class InvalidScriptNameError < ScriptProjectError; end
+
     class NoExistingAppsError < ScriptProjectError; end
     class NoExistingOrganizationsError < ScriptProjectError; end
+
     class NoExistingStoresError < ScriptProjectError
       attr_reader :organization_id
       def initialize(organization_id)
@@ -13,7 +15,10 @@ module Script
         @organization_id = organization_id
       end
     end
+
     class ScriptProjectAlreadyExistsError < ScriptProjectError; end
+    class InvalidConfigProps < ScriptProjectError; end
+
     class InvalidConfigYAMLError < ScriptProjectError
       attr_reader :config_file
       def initialize(config_file)
@@ -21,5 +26,22 @@ module Script
         @config_file = config_file
       end
     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 DeprecatedEPError < ScriptProjectError
+      attr_reader :ep
+      def initialize(ep)
+        super()
+        @ep = ep
+      end
+    end
   end
 end

data/lib/project_types/script/forms/create.rb

@@ -3,31 +3,55 @@
 module Script
   module Forms
     class Create < ShopifyCli::Form
-      flag_arguments :extension_point, :name
+      flag_arguments :extension_point, :name, :language, :description
 
       def ask
         self.name = valid_name
+        self.description ||= ask_description
         self.extension_point ||= ask_extension_point
+        self.language = ask_language
       end
 
       private
 
       def ask_extension_point
         CLI::UI::Prompt.ask(
-          @ctx.message('script.forms.create.select_extension_point'),
-          options: Script::Layers::Application::ExtensionPoints.types
+          @ctx.message("script.forms.create.select_extension_point"),
+          options: Layers::Application::ExtensionPoints.non_deprecated_types
         )
       end
 
       def ask_name
-        CLI::UI::Prompt.ask(@ctx.message('script.forms.create.script_name'))
+        CLI::UI::Prompt.ask(@ctx.message("script.forms.create.script_name"))
+      end
+
+      def ask_description
+        CLI::UI::Prompt.ask(@ctx.message("script.forms.create.description"))
       end
 
       def valid_name
-        n = (name || ask_name).downcase.gsub(' ', '_')
+        n = (name || ask_name).downcase.gsub(" ", "_")
         return n if n.match?(/^[0-9A-Za-z_-]*$/)
         raise Errors::InvalidScriptNameError
       end
+
+      def ask_language
+        if language
+          if Layers::Application::ExtensionPoints.supported_language?(type: extension_point, language: language)
+            return language.downcase
+          else
+            raise Errors::InvalidLanguageError.new(language, extension_point)
+          end
+        end
+
+        all_languages = Layers::Application::ExtensionPoints.languages(type: extension_point)
+        return all_languages.first if all_languages.count == 1
+
+        CLI::UI::Prompt.ask(
+          ctx.message("script.forms.create.select_language"),
+          options: all_languages
+        )
+      end
     end
   end
 end

data/lib/project_types/script/graphql/app_script_update_or_create.graphql

@@ -1,16 +1,26 @@
 mutation AppScriptUpdateOrCreate(
   $extensionPointName: ExtensionPointName!,
   $title: String,
+  $description: String,
+  $configUi: String,
   $sourceCode: String,
   $language: String,
-  $force: Boolean
+  $force: Boolean,
+  $schemaMajorVersion: String,
+  $schemaMinorVersion: String,
+  $useMsgpack: Boolean
 ) {
   appScriptUpdateOrCreate(
     extensionPointName: $extensionPointName
     title: $title
+    description: $description
+    configUi: $configUi
     sourceCode: $sourceCode
     language: $language
     force: $force
+    schemaMajorVersion: $schemaMajorVersion
+    schemaMinorVersion: $schemaMinorVersion
+    useMsgpack: $useMsgpack
 ) {
     userErrors {
       field
@@ -22,6 +32,7 @@ mutation AppScriptUpdateOrCreate(
       configSchema
       extensionPointName
       title
+      description
     }
   }
 }

data/lib/project_types/script/layers/application/build_script.rb

@@ -5,33 +5,33 @@ module Script
     module Application
       class BuildScript
         class << self
-          def call(ctx:, task_runner:, script:)
-            return if CLI::UI::Frame.open(ctx.message('script.application.building')) do
+          def call(ctx:, task_runner:, script_project:, config_ui:)
+            CLI::UI::Frame.open(ctx.message("script.application.building")) do
               begin
-                UI::StrictSpinner.spin(ctx.message('script.application.building_script')) do |spinner|
-                  build(ctx, task_runner, script)
-                  spinner.update_title(ctx.message('script.application.built'))
+                UI::StrictSpinner.spin(ctx.message("script.application.building_script")) do |spinner|
+                  Infrastructure::PushPackageRepository.new(ctx: ctx).create_push_package(
+                    script_project: script_project,
+                    script_content: task_runner.build,
+                    compiled_type: task_runner.compiled_type,
+                    metadata: task_runner.metadata,
+                    config_ui: config_ui,
+                  )
+                  spinner.update_title(ctx.message("script.application.built"))
                 end
-                true
               rescue StandardError => e
                 CLI::UI::Frame.with_frame_color_override(:red) do
                   ctx.puts("\n{{red:#{e.message}}}")
                 end
-                false
-              end
-            end
-            raise Infrastructure::Errors::BuildError
-          end
+                errors = [
+                  Infrastructure::Errors::InvalidBuildScriptError,
+                  Infrastructure::Errors::BuildScriptNotFoundError,
+                  Infrastructure::Errors::WebAssemblyBinaryNotFoundError,
+                ]
 
-          private
-
-          def build(ctx, task_runner, script)
-            script_repo = Infrastructure::ScriptRepository.new(ctx: ctx)
-            script_content = script_repo.with_temp_build_context do
-              task_runner.build
+                raise Infrastructure::Errors::BuildError unless errors.any? { |err| e.is_a?(err) }
+                raise
+              end
             end
-            Infrastructure::PushPackageRepository.new(ctx: ctx)
-              .create_push_package(script, script_content, task_runner.compiled_type)
           end
         end
       end

data/lib/project_types/script/layers/application/create_script.rb

@@ -7,42 +7,75 @@ module Script
     module Application
       class CreateScript
         class << self
-          def call(ctx:, language:, script_name:, extension_point_type:)
+          def call(ctx:, language:, script_name:, extension_point_type:, description:, no_config_ui:)
             extension_point = ExtensionPoints.get(type: extension_point_type)
-            project = setup_project(ctx, script_name, extension_point)
+            project = setup_project(
+              ctx: ctx,
+              language: language,
+              script_name: script_name,
+              extension_point: extension_point,
+              description: description,
+              no_config_ui: no_config_ui
+            )
             project_creator = Infrastructure::ProjectCreator
               .for(ctx, language, extension_point, script_name, project.directory)
-            install_dependencies(ctx, language, script_name, project.source_file, project_creator)
-            bootstrap(ctx, project.source_path, project_creator)
+            install_dependencies(ctx, language, script_name, project_creator)
+            bootstrap(ctx, project_creator)
             project
           end
 
           private
 
-          def setup_project(ctx, script_name, extension_point)
+          DEFAULT_CONFIG_UI_FILENAME = "config-ui.yml"
+
+          def setup_project(ctx:, language:, script_name:, extension_point:, description:, no_config_ui:)
             ScriptProject.create(ctx, script_name)
+
+            identifiers = {
+              extension_point_type: extension_point.type,
+              script_name: script_name,
+              language: language,
+              description: description,
+            }
+
+            unless no_config_ui
+              require "yaml" # takes 20ms, so deferred as late as possible.
+              identifiers.merge!(config_ui_file: DEFAULT_CONFIG_UI_FILENAME)
+              Infrastructure::ConfigUiRepository
+                .new(ctx: ctx)
+                .create_config_ui(DEFAULT_CONFIG_UI_FILENAME, default_config_ui_content(script_name))
+            end
+
             ScriptProject.write(
               ctx,
               project_type: :script,
               organization_id: nil, # TODO: can you provide this at creation
-              extension_point_type: extension_point.type,
-              script_name: script_name
+              **identifiers
             )
             ScriptProject.current
           end
 
-          def install_dependencies(ctx, language, script_name, source_file, project_creator)
-            task_runner = Infrastructure::TaskRunner.for(ctx, language, script_name, source_file)
+          def install_dependencies(ctx, language, script_name, project_creator)
+            task_runner = Infrastructure::TaskRunner.for(ctx, language, script_name)
             project_creator.setup_dependencies
             ProjectDependencies.install(ctx: ctx, task_runner: task_runner)
           end
 
-          def bootstrap(ctx, source_path, project_creator)
-            UI::StrictSpinner.spin(ctx.message('script.create.creating')) do |spinner|
+          def bootstrap(ctx, project_creator)
+            UI::StrictSpinner.spin(ctx.message("script.create.creating")) do |spinner|
               project_creator.bootstrap
-              spinner.update_title(ctx.message('script.create.created', source_path))
+              spinner.update_title(ctx.message("script.create.created"))
             end
           end
+
+          def default_config_ui_content(title)
+            YAML.dump({
+              "version" => 1,
+              "type" => "single",
+              "title" => title,
+              "fields" => [],
+            })
+          end
         end
       end
     end