shopify-cli 0.9.0

data/lib/project_types/extension/commands/build.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Extension
+  module Commands
+    class Build < ExtensionCommand
+      hidden_command
+
+      YARN_BUILD_COMMAND = %w(build)
+      NPM_BUILD_COMMAND = %w(run-script build)
+
+      def call(_args, _command_name)
+        system = ShopifyCli::JsSystem.new(ctx: @ctx)
+
+        CLI::UI::Frame.open(@ctx.message('build.frame_title', system.package_manager)) do
+          success = system.call(yarn: YARN_BUILD_COMMAND, npm: NPM_BUILD_COMMAND)
+          @ctx.abort(@ctx.message('build.build_failure_message')) unless success
+        end
+      end
+
+      def self.help
+        <<~HELP
+          Build your extension to prepare for deployment.
+            Usage: {{command:#{ShopifyCli::TOOL_NAME} build}}
+        HELP
+      end
+    end
+  end
+end

data/lib/project_types/extension/commands/create.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Extension
+  module Commands
+    class Create < ShopifyCli::SubCommand
+      options do |parser, flags|
+        parser.on('--name=NAME') { |name| flags[:name] = name }
+        parser.on('--type=TYPE') { |type| flags[:type] = type.upcase }
+      end
+
+      def call(args, _)
+        with_create_form(args) do |form|
+          if Dir.exist?(form.directory_name)
+            @ctx.abort(@ctx.message('create.errors.directory_exists', form.directory_name))
+          end
+
+          if form.type.create(form.directory_name, @ctx)
+            ExtensionProject.write_cli_file(context: @ctx, type: form.type.identifier)
+            ExtensionProject.write_env_file(context: @ctx, title: form.name)
+
+            @ctx.puts(@ctx.message('create.ready_to_start', form.directory_name, form.name))
+            @ctx.puts(@ctx.message('create.learn_more', form.type.name))
+          else
+            @ctx.puts(@ctx.message('create.try_again'))
+          end
+        end
+      end
+
+      def self.help
+        <<~HELP
+          Create a new app extension.
+            Usage: {{command:#{ShopifyCli::TOOL_NAME} create extension <name>}}
+            Options:
+              {{command:--type=TYPE}} The type of extension you would like to create.
+              {{command:--name=NAME}} The name of your extension (50 characters).”
+        HELP
+      end
+
+      private
+
+      def with_create_form(args)
+        form = Forms::Create.ask(@ctx, args, options.flags)
+        return @ctx.puts(self.class.help) if form.nil?
+
+        yield form
+      end
+    end
+  end
+end

data/lib/project_types/extension/commands/extension_command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Extension
+  module Commands
+    class ExtensionCommand < ShopifyCli::Command
+      def project
+        @project ||= ExtensionProject.current
+      end
+
+      def extension_type
+        @extension_type ||= begin
+          unless Models::Type.valid?(project.extension_type_identifier)
+            @ctx.abort(@ctx.message('errors.unknown_type', project.extension_type_identifier))
+          end
+
+          Models::Type.load_type(project.extension_type_identifier)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Extension
+  module Commands
+    class Push < ExtensionCommand
+      TIME_DISPLAY_FORMAT = "%B %d, %Y %H:%M:%S %Z"
+
+      def call(args, name)
+        Commands::Register.new(@ctx).call(args, name) unless project.registered?
+        Commands::Build.new(@ctx).call(args, name)
+
+        CLI::UI::Frame.open(@ctx.message('push.frame_title')) do
+          updated_draft_version = update_draft
+          show_message(updated_draft_version)
+        end
+      end
+
+      def self.help
+        <<~HELP
+          Push the current extension to Shopify.
+            Usage: {{command:#{ShopifyCli::TOOL_NAME} push}}
+        HELP
+      end
+
+      private
+
+      def show_message(draft)
+        draft.validation_errors.empty? ? output_success_messages(draft) : output_validation_errors(draft)
+      end
+
+      def output_success_messages(draft)
+        @ctx.puts(@ctx.message('push.success_confirmation', project.title, format_time(draft.last_user_interaction_at)))
+        @ctx.puts(@ctx.message('push.success_info', draft.location))
+      end
+
+      def output_validation_errors(draft)
+        @ctx.puts(@ctx.message('push.pushed_with_errors', format_time(draft.last_user_interaction_at)))
+
+        draft.validation_errors.each do |error|
+          @ctx.puts(format('{{x}} %s: %s', error.field.last, error.message))
+        end
+
+        @ctx.puts(@ctx.message('push.push_with_errors_info'))
+      end
+
+      def format_time(time)
+        time.utc.strftime(TIME_DISPLAY_FORMAT)
+      end
+
+      def with_waiting_text
+        @ctx.puts(@ctx.message('push.waiting_text'))
+        yield
+      end
+
+      def update_draft
+        with_waiting_text do
+          Tasks::UpdateDraft.call(
+            context: @ctx,
+            api_key: project.app.api_key,
+            registration_id: project.registration_id,
+            config: extension_type.config(@ctx),
+            extension_context: extension_type.extension_context(@ctx)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/project_types/extension/commands/register.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Extension
+  module Commands
+    class Register < ExtensionCommand
+      options do |parser, flags|
+        parser.on('--api_key=KEY') { |key| flags[:api_key] = key.downcase }
+      end
+
+      def call(args, _command_name)
+        CLI::UI::Frame.open(@ctx.message('register.frame_title')) do
+          @ctx.abort(@ctx.message('register.already_registered')) if project.registered?
+
+          with_register_form(args) do |form|
+            should_continue = confirm_registration(form.app)
+            registration = should_continue ? register_extension(form.app) : abort_not_registered
+
+            update_project_files(form.app, registration)
+
+            @ctx.puts(@ctx.message('register.success', project.title, form.app.title))
+            @ctx.puts(@ctx.message('register.success_info'))
+          end
+        end
+      end
+
+      def self.help
+        <<~HELP
+          Register your local extension to a Shopify app
+              Usage: {{command:#{ShopifyCli::TOOL_NAME} register}}
+              Options:
+                {{command:--api_key=API_KEY}} The API key used to register an app with the extension. This can be found on the app page on Partners Dashboard.
+        HELP
+      end
+
+      private
+
+      def with_register_form(args)
+        form = Forms::Register.ask(@ctx, args, options.flags)
+        return @ctx.puts(self.class.help) if form.nil?
+
+        yield form
+      end
+
+      def confirm_registration(app)
+        @ctx.puts(@ctx.message('register.confirm_info', extension_type.name))
+        CLI::UI::Prompt.confirm(@ctx.message('register.confirm_question', app.title))
+      end
+
+      def register_extension(app)
+        @ctx.puts(@ctx.message('register.waiting_text'))
+
+        Tasks::CreateExtension.call(
+          context: @ctx,
+          api_key: app.api_key,
+          type: extension_type.identifier,
+          title: project.title,
+          config: {},
+          extension_context: extension_type.extension_context(@ctx)
+        )
+      end
+
+      def update_project_files(app, registration)
+        ExtensionProject.write_env_file(
+          context: @ctx,
+          api_key: app.api_key,
+          api_secret: app.secret,
+          registration_id: registration.id,
+          title: project.title
+        )
+      end
+
+      def abort_not_registered
+        @ctx.puts(@ctx.message('register.confirm_abort'))
+        raise ShopifyCli::AbortSilent
+      end
+    end
+  end
+end

data/lib/project_types/extension/commands/serve.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Extension
+  module Commands
+    class Serve < ExtensionCommand
+      YARN_SERVE_COMMAND = %w(server)
+      NPM_SERVE_COMMAND = %w(run-script server)
+
+      def call(_args, _command_name)
+        CLI::UI::Frame.open(@ctx.message('serve.frame_title')) do
+          success = ShopifyCli::JsSystem.call(@ctx, yarn: YARN_SERVE_COMMAND, npm: NPM_SERVE_COMMAND)
+          @ctx.abort(@ctx.message('serve.serve_failure_message')) unless success
+        end
+      end
+
+      def self.help
+        <<~HELP
+          Serve your extension in a local simulator for development.
+            Usage: {{command:#{ShopifyCli::TOOL_NAME} serve}}
+        HELP
+      end
+    end
+  end
+end

data/lib/project_types/extension/commands/tunnel.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Extension
+  module Commands
+    class Tunnel < ExtensionCommand
+      options do |parser, flags|
+        parser.on('--port=PORT') { |port| flags[:port] = port }
+      end
+
+      AUTH_SUBCOMMAND = 'auth'
+      START_SUBCOMMAND = 'start'
+      STOP_SUBCOMMAND = 'stop'
+      STATUS_SUBCOMMAND = 'status'
+      DEFAULT_PORT = 39351
+
+      def call(args, _name)
+        subcommand = args.shift
+
+        case subcommand
+        when AUTH_SUBCOMMAND then authorize(args)
+        when START_SUBCOMMAND then ShopifyCli::Tunnel.start(@ctx, port: port)
+        when STOP_SUBCOMMAND then ShopifyCli::Tunnel.stop(@ctx)
+        when STATUS_SUBCOMMAND then status
+        else @ctx.puts(self.class.help)
+        end
+      end
+
+      def self.help
+        ShopifyCli::Context.message('tunnel.help', ShopifyCli::TOOL_NAME)
+      end
+
+      def self.extended_help
+        ShopifyCli::Context.message('tunnel.extended_help', ShopifyCli::TOOL_NAME, DEFAULT_PORT)
+      end
+
+      private
+
+      def status
+        tunnel_url = Features::TunnelUrl.fetch
+
+        if tunnel_url.nil?
+          @ctx.puts(@ctx.message('tunnel.no_tunnel_running'))
+        else
+          @ctx.puts(@ctx.message('tunnel.tunnel_running_at', tunnel_url))
+        end
+      end
+
+      def port
+        return DEFAULT_PORT unless options.flags.key?(:port)
+
+        port = options.flags[:port].to_i
+        @ctx.abort(@ctx.message('tunnel.invalid_port', options.flags[:port])) unless port > 0
+        port
+      end
+
+      def authorize(args)
+        token = args.shift
+
+        if token.nil?
+          @ctx.puts(@ctx.message('tunnel.missing_token'))
+          @ctx.puts("#{self.class.help}\n#{self.class.extended_help}")
+        else
+          ShopifyCli::Tunnel.auth(@ctx, token)
+        end
+      end
+    end
+  end
+end

data/lib/project_types/extension/extension_project.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Extension
+  class ExtensionProject < ShopifyCli::Project
+    class << self
+      def write_cli_file(context:, type:)
+        ShopifyCli::Project.write(
+          context,
+          project_type: :extension,
+          organization_id: nil,
+          "#{ExtensionProjectKeys::EXTENSION_TYPE_KEY}": type
+        )
+      end
+
+      def write_env_file(context:, title:, api_key: '', api_secret: '', registration_id: nil)
+        ShopifyCli::Resources::EnvFile.new(
+          api_key: api_key,
+          secret: api_secret,
+          extra: {
+            ExtensionProjectKeys::TITLE_KEY => title,
+            ExtensionProjectKeys::REGISTRATION_ID_KEY => registration_id,
+          }.compact
+        ).write(context)
+
+        current.reload unless project_empty?
+      end
+
+      private
+
+      def project_empty?
+        directory(Dir.pwd).nil?
+      end
+    end
+
+    def app
+      Models::App.new(api_key: env['api_key'], secret: env['secret'])
+    end
+
+    def registered?
+      property_present?('api_key') && property_present?('secret') && registration_id?
+    end
+
+    def title
+      get_extra_field(ExtensionProjectKeys::TITLE_KEY)
+    end
+
+    def extension_type_identifier
+      config[ExtensionProjectKeys::EXTENSION_TYPE_KEY]
+    end
+
+    def registration_id?
+      extra_property_present?(ExtensionProjectKeys::REGISTRATION_ID_KEY) &&
+        integer?(get_extra_field(ExtensionProjectKeys::REGISTRATION_ID_KEY)) &&
+        registration_id > 0
+    end
+
+    def registration_id
+      get_extra_field(ExtensionProjectKeys::REGISTRATION_ID_KEY).to_i
+    end
+
+    def reload
+      @env = nil
+    end
+
+    private
+
+    def get_extra_field(key)
+      extra = env[:extra] || {}
+      extra[key]
+    end
+
+    def extra_property_present?(key)
+      env[:extra].key?(key) && !get_extra_field(key).nil?
+    end
+
+    def property_present?(key)
+      !env[key].nil? && !env[key].strip.empty?
+    end
+
+    def integer?(value)
+      value.to_i.to_s == value.to_s
+    end
+  end
+end

data/lib/project_types/extension/extension_project_keys.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Extension
+  module ExtensionProjectKeys
+    REGISTRATION_ID_KEY = 'EXTENSION_ID'
+    EXTENSION_TYPE_KEY = 'EXTENSION_TYPE'
+    TITLE_KEY = 'EXTENSION_TITLE'
+  end
+end

data/lib/project_types/extension/features/argo.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'base64'
+
+module Extension
+  module Features
+    class Argo
+      include SmartProperties
+
+      GIT_ADMIN_TEMPLATE = 'https://github.com/Shopify/argo-admin-template.git'
+      GIT_CHECKOUT_TEMPLATE = 'https://github.com/Shopify/argo-checkout-template.git'
+      SCRIPT_PATH = %w(build main.js).freeze
+
+      class << self
+        def admin
+          @admin ||= Argo.new(setup: ArgoSetup.new(git_template: GIT_ADMIN_TEMPLATE))
+        end
+
+        def checkout
+          @checkout ||= Argo.new(
+            setup: ArgoSetup.new(
+              git_template: GIT_CHECKOUT_TEMPLATE,
+              dependency_checks: [ArgoDependencies.node_installed(min_major: 10, min_minor: 16)]
+            )
+          )
+        end
+      end
+
+      property! :setup, accepts: Features::ArgoSetup
+
+      def create(directory_name, identifier, context)
+        setup.call(directory_name, identifier, context)
+      end
+
+      def config(context)
+        filepath = File.join(context.root, SCRIPT_PATH)
+        context.abort(context.message('features.argo.missing_file_error')) unless File.exist?(filepath)
+
+        begin
+          {
+            serialized_script: Base64.strict_encode64(File.open(filepath).read.chomp),
+          }
+        rescue StandardError
+          context.abort(context.message('features.argo.script_prepare_error'))
+        end
+      end
+    end
+  end
+end