shopify-cli 2.6.5 → 2.7.2

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,51 +0,0 @@
-# frozen_string_literal: true
-module Rails
-  class Command
-    class Serve < ShopifyCLI::SubCommand
-      include ShopifyCLI::CommandOptions::CommandServeOptions
-
-      prerequisite_task ensure_project_type: :rails
-      prerequisite_task :ensure_env, :ensure_dev_store
-
-      parse_host_option
-      parse_port_option
-
-      def call(*)
-        project = ShopifyCLI::Project.current
-        tunnel_port = port.to_s
-        url = host || ShopifyCLI::Tunnel.start(@ctx, port: tunnel_port)
-        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"] = tunnel_port
-          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/project_types/script/tasks/ensure_env.rb

@@ -1,106 +0,0 @@
-require "shopify_cli"
-
-module Script
-  module Tasks
-    class EnsureEnv < ShopifyCLI::Task
-      attr_accessor :ctx
-
-      def call(ctx)
-        self.ctx = ctx
-
-        script_project_repo = Layers::Infrastructure::ScriptProjectRepository.new(ctx: ctx)
-        script_project = script_project_repo.get
-
-        return false if script_project.api_key && script_project.api_secret && script_project.uuid_defined?
-
-        org = ask_org
-        app = ask_app(org["apps"])
-        uuid = ask_script_uuid(app, script_project.extension_point_type)
-
-        script_project_repo.create_env(
-          api_key: app["apiKey"],
-          secret: app["apiSecretKeys"].first["secret"],
-          uuid: uuid
-        )
-
-        true
-      end
-
-      private
-
-      def ask_org
-        return stubbed_org if partner_proxy_bypass
-
-        if ShopifyCLI::Shopifolk.check && wants_to_run_against_shopify_org?
-          ShopifyCLI::Shopifolk.act_as_shopify_organization
-        end
-
-        orgs = ShopifyCLI::PartnersAPI::Organizations.fetch_with_app(ctx)
-        if orgs.count == 1
-          default = orgs.first
-          ctx.puts(ctx.message("script.application.ensure_env.organization", default["businessName"], default["id"]))
-          default
-        elsif orgs.count > 0
-          CLI::UI::Prompt.ask(ctx.message("script.application.ensure_env.organization_select")) do |handler|
-            orgs.each do |org|
-              handler.option("#{org["businessName"]} (#{org["id"]})") { org }
-            end
-          end
-        else
-          raise Errors::NoExistingOrganizationsError
-        end
-      end
-
-      def stubbed_org
-        {
-          "apps" => [
-            {
-              "appType" => "custom",
-              "apiKey" => "stubbed-api-key",
-              "apiSecretKeys" => [{ "secret" => "stubbed-api-secret" }],
-              "title" => "Fake App (Not connected to Partners)",
-            },
-          ],
-        }
-      end
-
-      def partner_proxy_bypass
-        !ENV["BYPASS_PARTNERS_PROXY"].nil?
-      end
-
-      def ask_app(apps)
-        unless ShopifyCLI::Shopifolk.acting_as_shopify_organization?
-          apps = apps.select { |app| app["appType"] == "custom" }
-        end
-
-        if apps.count == 1
-          default = apps.first
-          ctx.puts(ctx.message("script.application.ensure_env.app", default["title"]))
-          default
-        elsif apps.count > 0
-          CLI::UI::Prompt.ask(ctx.message("script.application.ensure_env.app_select")) do |handler|
-            apps.each do |app|
-              handler.option(app["title"]) { app }
-            end
-          end
-        else
-          raise Errors::NoExistingAppsError
-        end
-      end
-
-      def ask_script_uuid(app, extension_point_type)
-        script_service = Layers::Infrastructure::ServiceLocator.script_service(ctx: ctx, api_key: app["apiKey"])
-        scripts = script_service.get_app_scripts(extension_point_type: extension_point_type)
-
-        return nil unless scripts.count > 0 &&
-          CLI::UI::Prompt.confirm(ctx.message("script.application.ensure_env.ask_connect_to_existing_script"))
-
-        CLI::UI::Prompt.ask(ctx.message("script.application.ensure_env.ask_which_script_to_connect_to")) do |handler|
-          scripts.each do |script|
-            handler.option("#{script["title"]} (#{script["uuid"]})") { script["uuid"] }
-          end
-        end
-      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