shopify-cli 0.9.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Extension
+  module Features
+    class ArgoDependencies
+      def self.node_installed(min_major:, min_minor: nil)
+        -> (context) do
+          out, status = CLI::Kit::System.capture2('node', '-v')
+          context.abort(context.message('features.argo.dependencies.node.node_not_installed')) unless status.success?
+
+          min_version = 'v' + min_major .to_s + '.' + (min_minor.nil? ? 'x' : min_minor.to_s) + '.x'
+          version = out.strip
+          parsed_version = version.match(/v(?<major>\d+).(?<minor>\d+).(?<patch>\d+)/)
+
+          unless min_major.nil? || parsed_version[:major].to_i >= min_major
+            context.abort(context.message('features.argo.dependencies.node.version_too_low', version, min_version))
+          end
+
+          return if parsed_version[:major].to_i > min_major
+
+          unless min_minor.nil? || parsed_version[:minor].to_i >= min_minor
+            context.abort(context.message('features.argo.dependencies.node.version_too_low', version, min_version))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Extension
+  module Features
+    class ArgoSetup
+      include SmartProperties
+
+      GIT_DIRECTORY = '.git'
+      SCRIPTS_DIRECTORY = 'scripts'
+
+      property! :git_template, accepts: String
+      property! :dependency_checks, default: []
+
+      def call(directory_name, identifier, context)
+        steps = [
+          ArgoSetupSteps.check_dependencies(dependency_checks),
+          ArgoSetupSteps.clone_template(git_template),
+          ArgoSetupSteps.install_dependencies,
+          ArgoSetupSteps.initialize_project,
+        ]
+
+        install_result = run_install_steps(context, steps, identifier, directory_name)
+
+        cleanup(context, install_result, directory_name)
+        install_result
+      end
+
+      def run_install_steps(context, steps, identifier, directory_name)
+        system = ShopifyCli::JsSystem.new(ctx: context)
+
+        steps.inject(true) do |success, setup_step|
+          success && setup_step.call(context, identifier, directory_name, system)
+        end
+      end
+
+      def cleanup(context, install_result, directory_name)
+        install_result ? cleanup_template(context) : cleanup_on_failure(context, directory_name)
+      end
+
+      def cleanup_template(context)
+        context.rm_r(GIT_DIRECTORY)
+        context.rm_r(SCRIPTS_DIRECTORY)
+      rescue Errno::ENOENT => e
+        context.debug(e)
+      end
+
+      def cleanup_on_failure(context, directory_name)
+        FileUtils.rm_r(directory_name) if Dir.exist?(directory_name)
+      rescue Errno::ENOENT => e
+        context.debug(e)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Extension
+  module Features
+    class ArgoSetupStep
+      include SmartProperties
+
+      property! :step
+      property! :can_fail, accepts: [true, false], reader: :can_fail?
+
+      def call(context, identifier, directory_name, js_system)
+        step_result = step.call(context, identifier, directory_name, js_system)
+        can_fail? ? step_result : true
+      rescue ShopifyCli::Abort => e
+        context.puts(e.message)
+        false
+      rescue StandardError => e
+        context.puts("{{x}} #{e.message}")
+        false
+      end
+
+      def self.default(&block)
+        ArgoSetupStep.new(step: block, can_fail: true)
+      end
+
+      def self.always_successful(&block)
+        ArgoSetupStep.new(step: block, can_fail: false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Extension
+  module Features
+    module ArgoSetupSteps
+      YARN_INITIALIZE_COMMAND = %w(generate).freeze
+      NPM_INITIALIZE_COMMAND = %w(run generate --).freeze
+      INITIALIZE_TYPE_PARAMETER = '--type=%s'
+
+      def self.check_dependencies(dependency_checks)
+        ArgoSetupStep.always_successful do |context, _identifier, _directory_name, _js_system|
+          dependency_checks.each do |dependency_check|
+            dependency_check.call(context)
+          end
+        end
+      end
+
+      def self.clone_template(git_template)
+        ArgoSetupStep.default do |context, _identifier, directory_name, _js_system|
+          begin
+            ShopifyCli::Git.clone(git_template, directory_name, ctx: context)
+            context.root = File.join(context.root, directory_name)
+          rescue StandardError
+            context.puts('{{x}} Unable to clone the repository.')
+          end
+        end
+      end
+
+      def self.install_dependencies
+        ArgoSetupStep.default do |context, _identifier, _directory_name, js_system|
+          ShopifyCli::JsDeps.new(ctx: context, system: js_system).install
+        end
+      end
+
+      def self.initialize_project
+        ArgoSetupStep.default do |context, identifier, _directory_name, js_system|
+          frame_title = context.message('create.setup_project_frame_title')
+          failure_message = context.message('features.argo.initialization_error')
+
+          result = true
+          CLI::UI::Frame.open(frame_title, failure_text: failure_message) do
+            result = js_system.call(
+              yarn: YARN_INITIALIZE_COMMAND + [INITIALIZE_TYPE_PARAMETER % identifier],
+              npm: NPM_INITIALIZE_COMMAND + [INITIALIZE_TYPE_PARAMETER % identifier]
+            )
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'base64'
+
+module Extension
+  module Features
+    module TunnelUrl
+      NGROK_TUNNELS_URI = URI.parse('http://localhost:4040/api/tunnels')
+      TUNNELS_FIELD = 'tunnels'
+      PUBLIC_URL_FIELD = 'public_url'
+
+      def self.fetch
+        response = Net::HTTP.get_response(NGROK_TUNNELS_URI)
+        json = JSON.parse(response.body)
+        json.dig(TUNNELS_FIELD, 0, PUBLIC_URL_FIELD)
+      rescue
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Extension
+  module Forms
+    class Create < ShopifyCli::Form
+      flag_arguments :name, :type
+
+      def ask
+        self.type = ask_type
+        self.name = ask_name
+      end
+
+      def directory_name
+        @directory_name ||= name.strip.gsub(/( )/, '_').downcase
+      end
+
+      private
+
+      def ask_name
+        ask_with_reprompt(
+          initial_value: name,
+          break_condition: -> (current_name) { Models::Registration.valid_title?(current_name) },
+          prompt_message: ctx.message('create.ask_name'),
+          reprompt_message: ctx.message('create.invalid_name', Models::Registration::MAX_TITLE_LENGTH)
+        )
+      end
+
+      def ask_type
+        return Models::Type.load_type(type) if Models::Type.valid?(type)
+        ctx.puts(ctx.message('create.invalid_type')) unless type.nil?
+
+        CLI::UI::Prompt.ask(ctx.message('create.ask_type')) do |handler|
+          Models::Type.repository.values.each do |type|
+            handler.option("#{type.name} #{type.tagline}") { type }
+          end
+        end
+      end
+
+      def ask_with_reprompt(initial_value:, break_condition:, prompt_message:, reprompt_message:)
+        value = initial_value
+        reprompt = false
+
+        until break_condition.call(value)
+          ctx.puts(reprompt_message) if reprompt
+          value = CLI::UI::Prompt.ask(prompt_message)&.strip
+          reprompt = true
+        end
+        value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Extension
+  module Forms
+    class Register < ShopifyCli::Form
+      flag_arguments :api_key
+
+      attr_reader :app
+
+      def ask
+        self.app = ask_app
+      end
+
+      private
+
+      attr_writer :app
+
+      def ask_app
+        apps = load_apps
+
+        if !api_key.nil?
+          found_app = apps.find { |app| app.api_key == api_key }
+          ctx.abort(ctx.message('register.invalid_api_key', api_key)) if found_app.nil?
+          found_app
+        else
+          CLI::UI::Prompt.ask(ctx.message('register.ask_app')) do |handler|
+            apps.each do |app|
+              handler.option("#{app.title} by #{app.business_name}") { app }
+            end
+          end
+        end
+      end
+
+      def load_apps
+        ctx.puts(@ctx.message('register.loading_apps'))
+        apps = Tasks::GetApps.call(context: ctx)
+
+        apps.empty? ? abort_no_apps : apps
+      end
+
+      def abort_no_apps
+        ctx.puts(@ctx.message('register.no_apps'))
+        ctx.puts(@ctx.message('register.learn_about_apps'))
+        raise ShopifyCli::AbortSilent
+      end
+    end
+  end
+end

data/lib/project_types/extension/messages/message_loading.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Extension
+  module Messages
+    module MessageLoading
+      def self.load
+        type_specific_messages = load_current_type_messages
+        return Messages::MESSAGES if type_specific_messages.nil?
+
+        if type_specific_messages.key?(:overrides)
+          deep_merge(Messages::MESSAGES, type_specific_messages[:overrides])
+        else
+          Messages::MESSAGES
+        end
+      end
+
+      def self.load_current_type_messages
+        return unless ShopifyCli::Project.has_current?
+        messages_for_type(ShopifyCli::Project.current.config[Extension::ExtensionProjectKeys::EXTENSION_TYPE_KEY])
+      end
+
+      def self.messages_for_type(type_identifier)
+        return if type_identifier.nil?
+
+        type_identifier_symbol = type_identifier.downcase.to_sym
+        return unless Messages::TYPES.key?(type_identifier_symbol)
+
+        TYPES[type_identifier_symbol]
+      end
+
+      def self.deep_merge(first, second)
+        merger = proc { |_key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+        first.merge(second, &merger)
+      end
+    end
+  end
+end

data/lib/project_types/extension/messages/messages.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Extension
+  module Messages
+    MESSAGES = {
+      create: {
+        ask_name: 'Extension name',
+        invalid_name: 'Extension name must be under %s characters',
+        ask_type: 'What type of extension are you creating?',
+        invalid_type: 'Extension type is invalid.',
+        setup_project_frame_title: 'Initializing project',
+        ready_to_start: <<~MESSAGE,
+          {{v}} A new folder was generated at {{green:./%s}}.
+          {{*}} You’re ready to start building {{green:%s}}!
+          Navigate to the new folder, then run {{command:shopify serve}} to start a local server.
+        MESSAGE
+        learn_more: <<~MESSAGE,
+          {{*}} Once you're ready to version and publish your extension,
+          run {{command:shopify register}} to register this extension with one of your apps.
+        MESSAGE
+        try_again: '{{*}} Fix the errors and run {{command:shopify create extension}} again.',
+        errors: {
+          directory_exists: 'Directory ‘%s’ already exists. Please remove it or choose a new name for your project.',
+        },
+      },
+      build: {
+        frame_title: 'Building extension with: %s...',
+        build_failure_message: 'Failed to build extension code.',
+      },
+      register: {
+        frame_title: 'Registering Extension',
+        waiting_text: 'Registering with Shopify...',
+        already_registered: 'Extension is already registered.',
+        loading_apps: 'Loading your apps...',
+        ask_app: 'Which app would you like to register this extension with?',
+        no_apps: '{{x}} You don’t have any apps.',
+        learn_about_apps: '{{*}} Learn more about building apps at <https://shopify.dev/concepts/apps>, ' \
+          'or try creating a new app using {{command:shopify create}}.',
+        invalid_api_key: 'The API key %s does not match any of your apps.',
+        confirm_info: 'This will create a new extension registration for %s, which can’t be undone.',
+        confirm_question: 'Would you like to register this extension with {{green:%s}}? (y/n)',
+        confirm_abort: 'Extension was not registered.',
+        success: '{{v}} Registered {{green:%s}} with {{green:%s}}.',
+        success_info: '{{*}} Run {{command:shopify push}} to push your extension to Shopify.',
+      },
+      push: {
+        frame_title: 'Pushing your extension to Shopify',
+        waiting_text: 'Pushing code to Shopify...',
+        pushed_with_errors: '{{x}} Code pushed to Shopify with errors on %s.',
+        push_with_errors_info: '{{*}} Fix these errors and run {{command:shopify push}} to revalidate your extension.',
+        success_confirmation: '{{v}} Pushed {{green:%s}} to a draft on %s.',
+        success_info: '{{*}} Visit %s to version and publish your extension.',
+      },
+      serve: {
+        frame_title: 'Serving extension...',
+        serve_failure_message: 'Failed to run extension code.',
+      },
+      tunnel: {
+        missing_token: '{{x}} {{red:auth requires a token argument}}. '\
+          'Find it on your ngrok dashboard: {{underline:https://dashboard.ngrok.com/auth/your-authtoken}}.',
+        invalid_port: '%s is not a valid port.',
+        no_tunnel_running: 'No tunnel running.',
+        tunnel_running_at: 'Tunnel running at: {{underline:%s}}',
+        help: <<~HELP,
+          Start or stop an http tunnel to your local development extension using ngrok.
+            Usage: {{command:%s tunnel [ auth | start | stop | status ]}}
+        HELP
+        extended_help: <<~HELP,
+          {{bold:Subcommands:}}
+
+            {{cyan:auth}}: Writes an ngrok auth token to ~/.ngrok2/ngrok.yml to connect with an ngrok account. 
+            Visit https://dashboard.ngrok.com/signup to sign up.
+              Usage: {{command:%1$s tunnel auth <token>}}
+
+            {{cyan:start}}: Starts an ngrok tunnel, will print the URL for an existing tunnel if already running.
+              Usage: {{command:%1$s tunnel start}}
+              Options:
+              {{command:--port=PORT}} Forward the ngrok subdomain to local port PORT. Defaults to %2$s.
+
+            {{cyan:stop}}: Stops the ngrok tunnel.
+              Usage: {{command:%1$s tunnel stop}}
+
+            {{cyan:status}}: Output the current status of the ngrok tunnel.
+              Usage: {{command:%1$s tunnel status}}
+        HELP
+      },
+      features: {
+        argo: {
+          missing_file_error: 'Could not find built extension file.',
+          script_prepare_error: 'An error occurred while attempting to prepare your script.',
+          initialization_error: '{{x}} There was an error while initializing the project.',
+          dependencies: {
+            node: {
+              node_not_installed: 'Node must be installed to create this extension.',
+              version_too_low: 'Your node version %s does not meet the minimum required version %s',
+            },
+          },
+        },
+      },
+      tasks: {
+        errors: {
+          parse_error: 'Unable to parse response from Partners Dashboard.',
+        },
+      },
+      errors: {
+        unknown_type: 'Unknown extension type %s',
+      },
+    }
+
+    TYPES = {
+      subscription_management: {
+        name: 'Subscription Management',
+        tagline: '(limit 1 per app)',
+        overrides: {
+          register: {
+            confirm_info: 'You can only create one %s extension per app, which can’t be undone.',
+          },
+        },
+      },
+      checkout_post_purchase: {
+        name: 'Checkout Post Purchase',
+      },
+    }
+  end
+end