shopify-cli 2.6.3 → 2.7.0

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli"
-
-module PHP
-  class Command
-    class Tunnel < ShopifyCLI::SubCommand
-      def call(args, _name)
-        subcommand = args.shift
-        case subcommand
-        when "auth"
-          token = args.shift
-          if token.nil?
-            @ctx.puts(@ctx.message("php.tunnel.error.token_argument_missing"))
-            @ctx.puts("#{self.class.help}\n#{self.class.extended_help}")
-          else
-            ShopifyCLI::Tunnel.auth(@ctx, token)
-          end
-        when "start"
-          ShopifyCLI::Tunnel.start(@ctx)
-        when "stop"
-          ShopifyCLI::Tunnel.stop(@ctx)
-        else
-          @ctx.puts(self.class.help)
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("php.tunnel.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      def self.extended_help
-        ShopifyCLI::Context.message("php.tunnel.extended_help", ShopifyCLI::TOOL_NAME)
-      end
-    end
-  end
-end

data/lib/project_types/rails/commands/connect.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-module Rails
-  class Command
-    class Connect < ShopifyCLI::SubCommand
-      prerequisite_task ensure_project_type: :rails
-
-      def call(*)
-        if ShopifyCLI::Project.has_current? && ShopifyCLI::Project.current.env
-          @ctx.puts(@ctx.message("rails.connect.production_warning"))
-        end
-
-        app = ShopifyCLI::Connect.new(@ctx).default_connect("rails")
-        @ctx.done(@ctx.message("rails.connect.connected", app))
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("rails.connect.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
-      end
-    end
-  end
-end

data/lib/project_types/rails/commands/deploy/heroku.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module Rails
-  class Command
-    class Deploy
-      class Heroku
-        class << self
-          DB_CHECK_CMD = 'bundle exec rails runner "puts ActiveRecord::Base.connection.adapter_name.downcase"'
-
-          def help
-            ShopifyCLI::Context.message("rails.deploy.heroku.help", ShopifyCLI::TOOL_NAME)
-          end
-
-          def start(ctx)
-            CLI::UI::Frame.open(ctx.message("rails.deploy.heroku.db_check.validating")) do
-              CLI::UI::Spinner.spin(ctx.message("rails.deploy.heroku.db_check.checking")) do |spinner|
-                db_type, err = check_db(ctx)
-                ctx.abort(ctx.message(err)) unless err.nil?
-                spinner.update_title(ctx.message("rails.deploy.heroku.db_check.validated", db_type))
-              end
-              true
-            end
-
-            spin_group = CLI::UI::SpinGroup.new
-            heroku_service = ShopifyCLI::Heroku.new(ctx)
-
-            spin_group.add(ctx.message("rails.deploy.heroku.downloading")) do |spinner|
-              heroku_service.download
-              spinner.update_title(ctx.message("rails.deploy.heroku.downloaded"))
-            end
-            spin_group.wait
-
-            spin_group.add(ctx.message("rails.deploy.heroku.installing")) do |spinner|
-              heroku_service.install
-              spinner.update_title(ctx.message("rails.deploy.heroku.installed"))
-            end
-            spin_group.add(ctx.message("rails.deploy.heroku.git.checking")) do |spinner|
-              ShopifyCLI::Git.init(ctx)
-              spinner.update_title(ctx.message("rails.deploy.heroku.git.initialized"))
-            end
-            spin_group.wait
-
-            if (account = heroku_service.whoami)
-              ctx.puts(ctx.message("rails.deploy.heroku.authenticated_with_account", account))
-            else
-              CLI::UI::Frame.open(
-                ctx.message("rails.deploy.heroku.authenticating"),
-                success_text: ctx.message("rails.deploy.heroku.authenticated")
-              ) do
-                heroku_service.authenticate
-              end
-            end
-
-            if (app_name = heroku_service.app)
-              ctx.puts(ctx.message("rails.deploy.heroku.app.selected", app_name))
-            else
-              app_type = CLI::UI::Prompt.ask(ctx.message("rails.deploy.heroku.app.no_apps_found")) do |handler|
-                handler.option(ctx.message("rails.deploy.heroku.app.create")) { :new }
-                handler.option(ctx.message("rails.deploy.heroku.app.select")) { :existing }
-              end
-
-              if app_type == :existing
-                app_name = CLI::UI::Prompt.ask(ctx.message("rails.deploy.heroku.app.name"))
-                CLI::UI::Frame.open(
-                  ctx.message("rails.deploy.heroku.app.selecting", app_name),
-                  success_text: ctx.message("rails.deploy.heroku.app.selected", app_name)
-                ) do
-                  heroku_service.select_existing_app(app_name)
-                end
-              elsif app_type == :new
-                CLI::UI::Frame.open(
-                  ctx.message("rails.deploy.heroku.app.creating"),
-                  success_text: ctx.message("rails.deploy.heroku.app.created")
-                ) do
-                  heroku_service.create_new_app
-                end
-              end
-            end
-
-            branches = ShopifyCLI::Git.branches(ctx)
-            if branches.length == 1
-              branch_to_deploy = branches[0]
-              ctx.puts(ctx.message("rails.deploy.heroku.git.branch_selected", branch_to_deploy))
-            else
-              branch_to_deploy = CLI::UI::Prompt.ask(ctx.message("rails.deploy.heroku.git.what_branch")) do |handler|
-                branches.each do |branch|
-                  handler.option(branch) { branch }
-                end
-              end
-            end
-
-            CLI::UI::Frame.open(
-              ctx.message("rails.deploy.heroku.deploying"),
-              success_text: ctx.message("rails.deploy.heroku.deployed")
-            ) do
-              heroku_service.deploy(branch_to_deploy)
-            end
-          end
-
-          def check_db(ctx)
-            out, stat = ctx.capture2e(DB_CHECK_CMD)
-            if stat.success? && out.strip == "sqlite"
-              ["sqlite", "rails.deploy.heroku.db_check.sqlite"]
-            elsif !stat.success?
-              [nil, "rails.deploy.heroku.db_check.problem"]
-            else
-              [out.strip, nil]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/project_types/rails/commands/deploy.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module Rails
-  class Command
-    class Deploy < ShopifyCLI::SubCommand
-      prerequisite_task ensure_project_type: :rails
-
-      autoload :Heroku, Project.project_filepath("commands/deploy/heroku")
-
-      HEROKU = "heroku"
-
-      def call(args, _name)
-        subcommand = args.shift
-        case subcommand
-        when HEROKU
-          Rails::Command::Deploy::Heroku.start(@ctx)
-        else
-          @ctx.puts(self.class.help)
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("rails.deploy.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      def self.extended_help
-        ShopifyCLI::Context.message("rails.deploy.extended_help", ShopifyCLI::TOOL_NAME)
-      end
-    end
-  end
-end

data/lib/project_types/rails/commands/generate/webhook.rb

@@ -1,42 +0,0 @@
-require "shopify_cli"
-require "json"
-module Rails
-  class Command
-    class Generate
-      class Webhook
-        class << self
-          def start(ctx, args)
-            selected_type = args.first
-            schema = ShopifyCLI::AdminAPI::Schema.get(ctx)
-            webhooks = schema.get_names_from_type("WebhookSubscriptionTopic")
-            unless selected_type && webhooks.include?(selected_type)
-              selected_type = CLI::UI::Prompt.ask(ctx.message("rails.generate.webhook.select")) do |handler|
-                webhooks.each do |type|
-                  handler.option(type) { type }
-                end
-              end
-            end
-            spin_group = CLI::UI::SpinGroup.new
-            spin_group.add(ctx.message("rails.generate.webhook.selected", selected_type)) do |spinner|
-              Rails::Command::Generate.run_generate(generate_command(selected_type, ctx), selected_type, ctx)
-              spinner.update_title("{{green:#{selected_type}}} config/initializers/shopify_app.rb")
-            end
-            spin_group.wait
-          end
-
-          def help
-            ShopifyCLI::Context.message("rails.generate.webhook.help", ShopifyCLI::TOOL_NAME)
-          end
-
-          def generate_command(selected_type, ctx)
-            parts = selected_type.downcase.split("_")
-            host = ShopifyCLI::Project.current.env.host
-            selected_type = parts[0..-2].join("_") + "/" + parts[-1]
-            command = ctx.windows? ? "ruby bin\\rails" : "bin/rails"
-            "#{command} g shopify_app:add_webhook -t #{selected_type} -a #{host}/webhooks/#{selected_type.downcase}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/project_types/rails/commands/generate.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module Rails
-  class Command
-    class Generate < ShopifyCLI::SubCommand
-      prerequisite_task ensure_project_type: :rails
-
-      autoload :Webhook, Project.project_filepath("commands/generate/webhook")
-
-      WEBHOOK = "webhook"
-
-      def call(args, _name)
-        subcommand = args.shift
-        case subcommand
-        when WEBHOOK
-          Rails::Command::Generate::Webhook.start(@ctx, args)
-        else
-          @ctx.puts(self.class.help)
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("rails.generate.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      def self.extended_help
-        extended_help = "{{bold:Subcommands:}}\n"
-        subcommand_registry.resolved_commands.sort.each do |name, klass|
-          extended_help += "  {{cyan:#{name}}}: "
-
-          if (subcmd_help = klass.help)
-            extended_help += subcmd_help.gsub("\n  ", "\n    ")
-          end
-          extended_help += "\n"
-        end
-        extended_help += ShopifyCLI::Context.message("rails.generate.extended_help", ShopifyCLI::TOOL_NAME)
-      end
-
-      def self.run_generate(script, name, ctx)
-        Gem.gem_path(ctx)
-        stat = ctx.system(script)
-        unless stat.success?
-          ctx.abort(response(stat.exitstatus, name, ctx))
-        end
-      end
-
-      def self.response(code, name, ctx)
-        case code
-        when 1
-          ctx.message("rails.generate.error.generic", name)
-        when 2
-          ctx.message("rails.generate.error.name_exists", name)
-        else
-          ctx.message("rails.error.generic")
-        end
-      end
-    end
-  end
-end

data/lib/project_types/rails/commands/open.rb

@@ -1,18 +0,0 @@
-require "shopify_cli"
-
-module Rails
-  class Command
-    class Open < ShopifyCLI::SubCommand
-      prerequisite_task ensure_project_type: :rails
-
-      def call(*)
-        project = ShopifyCLI::Project.current
-        @ctx.open_url!("#{project.env.host}/login?shop=#{project.env.shop}")
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("rails.open.help", ShopifyCLI::TOOL_NAME)
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-module Rails
-  class Command
-    class Serve < ShopifyCLI::SubCommand
-      prerequisite_task ensure_project_type: :rails
-      prerequisite_task :ensure_env, :ensure_dev_store
-
-      options do |parser, flags|
-        parser.on("--host=HOST") do |h|
-          flags[:host] = h.gsub('"', "")
-        end
-      end
-
-      def call(*)
-        project = ShopifyCLI::Project.current
-        url = options.flags[:host] || ShopifyCLI::Tunnel.start(@ctx)
-        @ctx.abort(@ctx.message("rails.serve.error.host_must_be_https")) if url.match(/^https/i).nil?
-        project.env.update(@ctx, :host, url)
-        ShopifyCLI::Tasks::UpdateDashboardURLS.call(
-          @ctx,
-          url: url,
-          callback_url: "/auth/shopify/callback",
-        )
-
-        if project.env.shop
-          project_url = "#{project.env.host}/login?shop=#{project.env.shop}"
-          @ctx.puts("\n" + @ctx.message("rails.serve.open_info", project_url) + "\n")
-        end
-
-        CLI::UI::Frame.open(@ctx.message("rails.serve.running_server")) do
-          env = ShopifyCLI::Project.current.env.to_h
-          env.delete("HOST")
-          env["PORT"] = ShopifyCLI::Tunnel::PORT.to_s
-          env["GEM_PATH"] = Gem.gem_path(@ctx)
-          if @ctx.windows?
-            @ctx.system("ruby bin\\rails server", env: env)
-          else
-            @ctx.system("bin/rails server", env: env)
-          end
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("rails.serve.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      def self.extended_help
-        ShopifyCLI::Context.message("rails.serve.extended_help", ShopifyCLI::TOOL_NAME)
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli"
-
-module Rails
-  class Command
-    class Tunnel < ShopifyCLI::SubCommand
-      # subcommands :auth, :start, :stop
-
-      prerequisite_task ensure_project_type: :rails
-
-      def call(args, _name)
-        subcommand = args.shift
-        case subcommand
-        when "auth"
-          token = args.shift
-          if token.nil?
-            @ctx.puts(@ctx.message("rails.tunnel.error.token_argument_missing"))
-            @ctx.puts("#{self.class.help}\n#{self.class.extended_help}")
-          else
-            ShopifyCLI::Tunnel.auth(@ctx, token)
-          end
-        when "start"
-          ShopifyCLI::Tunnel.start(@ctx)
-        when "stop"
-          ShopifyCLI::Tunnel.stop(@ctx)
-        else
-          @ctx.puts(self.class.help)
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("rails.tunnel.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      def self.extended_help
-        ShopifyCLI::Context.message("rails.tunnel.extended_help", ShopifyCLI::TOOL_NAME)
-      end
-    end
-  end
-end

data/lib/shopify_cli/exception_reporter/permission_controller.rb

@@ -1,54 +0,0 @@
-module ShopifyCLI
-  module ExceptionReporter
-    module PermissionController
-      def self.report_error?(context: ShopifyCLI::Context.new)
-        CLI::UI::Prompt.ask(context.message("core.error_reporting.report_error.question")) do |handler|
-          handler.option(context.message("core.error_reporting.report_error.yes")) { |_| true }
-          handler.option(context.message("core.error_reporting.report_error.no")) { |_| false }
-        end
-      end
-
-      def self.automatic_reporting_prompted?
-        ShopifyCLI::Config.get_section(Constants::Config::Sections::ErrorTracking::NAME).key?(
-          Constants::Config::Sections::ErrorTracking::Fields::AUTOMATIC_REPORTING
-        )
-      end
-
-      def self.can_report_automatically?(context: ShopifyCLI::Context.new)
-        # If the terminal is not interactive we can't prompt the user.
-        return false unless ShopifyCLI::Environment.interactive?
-
-        if automatic_reporting_prompted?
-          automatic_reporting_enabled?
-        else
-          prompt_user(context: context)
-        end
-      end
-
-      def self.prompt_user(context:)
-        enable_automatic_tracking = CLI::UI::Prompt.ask(
-          context.message("core.error_reporting.enable_automatic_reporting_prompt.question")
-        ) do |handler|
-          handler.option(context.message("core.error_reporting.enable_automatic_reporting_prompt.yes")) { |_| true }
-          handler.option(context.message("core.error_reporting.enable_automatic_reporting_prompt.no")) { |_| false }
-        end
-
-        ShopifyCLI::Config.set(
-          Constants::Config::Sections::ErrorTracking::NAME,
-          Constants::Config::Sections::ErrorTracking::Fields::AUTOMATIC_REPORTING,
-          enable_automatic_tracking
-        )
-
-        enable_automatic_tracking
-      end
-
-      def self.automatic_reporting_enabled?
-        ShopifyCLI::Config.get_bool(
-          Constants::Config::Sections::ErrorTracking::NAME,
-          Constants::Config::Sections::ErrorTracking::Fields::AUTOMATIC_REPORTING,
-          default: false
-        )
-      end
-    end
-  end
-end

data/lib/shopify_cli/sub_command.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module ShopifyCLI
-  class SubCommand < Command
-    class << self
-      def call(args, command_name, parent_command)
-        cmd = new(@ctx)
-        args = cmd.options.parse(@_options, args[1..-1] || [])
-        return call_help(parent_command, command_name) if cmd.options.help
-        run_prerequisites
-
-        cmd.call(args, command_name)
-      end
-    end
-  end
-end

data/shopify.fish

@@ -1,12 +0,0 @@
-#!/usr/bin/env fish
-# vi: ft=fish
-
-# If we're not already in a shim environment but still tried to set up a shim, print out the re-installation warning
-type -t shopify > /dev/null 2>&1
-if [ $status != "0" ]
-  echo "This version of Shopify CLI is no longer supported. You’ll need to migrate to the new CLI version to continue.
-
-Please visit this page for complete instructions:
-  https://shopify.dev/tools/cli/troubleshooting#migrate-from-a-legacy-version
-"
-end

data/shopify.sh

@@ -1,11 +0,0 @@
-#!/bin/sh
-
-# If we're not already in a shim environment but still tried to set up a shim, print out the re-installation warning
-typeset -f shopify > /dev/null 2>&1
-if [ "$?" != "0" ]; then
-  echo "This version of Shopify CLI is no longer supported. You’ll need to migrate to the new CLI version to continue.
-
-Please visit this page for complete instructions:
-  https://shopify.dev/tools/cli/troubleshooting#migrate-from-a-legacy-version
-"
-fi