shopify-cli 0.9.0

data/lib/project_types/rails/cli.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Rails
+  class Project < ShopifyCli::ProjectType
+    # hidden_project_type
+    creator 'Ruby on Rails App', 'Rails::Commands::Create'
+
+    register_command('Rails::Commands::Deploy', "deploy")
+    register_command('Rails::Commands::Generate', "generate")
+    register_command('Rails::Commands::Open', "open")
+    register_command('Rails::Commands::Populate', "populate")
+    register_command('Rails::Commands::Serve', "serve")
+    register_command('Rails::Commands::Tunnel', "tunnel")
+    # register_task('Rails::Tasks::RailsTask', 'rails_task')
+
+    require Project.project_filepath('messages/messages')
+    register_messages(Rails::Messages::MESSAGES)
+  end
+
+  # define/autoload project specific Commands
+  module Commands
+    autoload :Create, Project.project_filepath('commands/create')
+    autoload :Deploy, Project.project_filepath('commands/deploy')
+    autoload :Generate, Project.project_filepath('commands/generate')
+    autoload :Open, Project.project_filepath('commands/open')
+    autoload :Populate, Project.project_filepath('commands/populate')
+    autoload :Serve, Project.project_filepath('commands/serve')
+    autoload :Tunnel, Project.project_filepath('commands/tunnel')
+  end
+
+  # define/autoload project specific Tasks
+  module Tasks
+  end
+
+  # define/autoload project specific Forms
+  module Forms
+    autoload :Create, Project.project_filepath('forms/create')
+  end
+
+  autoload :Ruby, Project.project_filepath('ruby')
+  autoload :Gem, Project.project_filepath('gem')
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+module Rails
+  module Commands
+    class Create < ShopifyCli::SubCommand
+      USER_AGENT_CODE = <<~USERAGENT
+        module ShopifyAPI
+          class Base < ActiveResource::Base
+            self.headers['User-Agent'] << " | ShopifyApp/\#{ShopifyApp::VERSION} | Shopify App CLI"
+          end
+        end
+      USERAGENT
+
+      DEFAULT_RAILS_FLAGS = %w(--skip-spring)
+
+      options do |parser, flags|
+        # backwards compatibility allow 'title' for now
+        parser.on('--title=TITLE') { |t| flags[:title] = t }
+        parser.on('--name=NAME') { |t| flags[:title] = t }
+        parser.on('--organization_id=ID') { |url| flags[:organization_id] = url }
+        parser.on('--shop_domain=MYSHOPIFYDOMAIN') { |url| flags[:shop_domain] = url }
+        parser.on('--type=APPTYPE') { |url| flags[:type] = url }
+        parser.on('--db=DB') { |db| flags[:db] = db }
+        parser.on('--rails_opts=RAILSOPTS') { |opts| flags[:rails_opts] = opts }
+      end
+
+      def call(args, _name)
+        form = Forms::Create.ask(@ctx, args, options.flags)
+        return @ctx.puts(self.class.help) if form.nil?
+
+        @ctx.abort(@ctx.message('rails.create.error.invalid_ruby_version')) unless
+          Ruby.version(@ctx).satisfies?('~>2.5')
+
+        build(form.name, form.db)
+        set_custom_ua
+        ShopifyCli::Project.write(
+          @ctx,
+          project_type: 'rails',
+          organization_id: form.organization_id,
+        )
+
+        api_client = ShopifyCli::Tasks::CreateApiClient.call(
+          @ctx,
+          org_id: form.organization_id,
+          title: form.title,
+          type: form.type,
+        )
+
+        ShopifyCli::Resources::EnvFile.new(
+          api_key: api_client["apiKey"],
+          secret: api_client["apiSecretKeys"].first["secret"],
+          shop: form.shop_domain,
+          scopes: 'write_products,write_customers,write_draft_orders',
+        ).write(@ctx)
+
+        partners_url = "https://partners.shopify.com/#{form.organization_id}/apps/#{api_client['id']}"
+
+        @ctx.puts(@ctx.message('rails.create.info.created', form.title, partners_url))
+        @ctx.puts(@ctx.message('rails.create.info.serve', form.name, ShopifyCli::TOOL_NAME))
+        @ctx.puts(@ctx.message('rails.create.info.install', partners_url, form.title))
+      end
+
+      def self.help
+        ShopifyCli::Context.message('rails.create.help', ShopifyCli::TOOL_NAME, ShopifyCli::TOOL_NAME)
+      end
+
+      private
+
+      def build(name, db)
+        install_gem('rails')
+        CLI::UI::Frame.open(@ctx.message('rails.create.installing_bundler')) do
+          install_gem('bundler', '~>1.0')
+          install_gem('bundler', '~>2.0')
+        end
+
+        CLI::UI::Frame.open(@ctx.message('rails.create.generating_app', name)) do
+          new_command = %w(rails new)
+          new_command += DEFAULT_RAILS_FLAGS
+          new_command << "--database=#{db}"
+          new_command += options.flags[:rails_opts].split unless options.flags[:rails_opts].nil?
+          new_command << name
+
+          syscall(new_command)
+        end
+
+        @ctx.root = File.join(@ctx.root, name)
+
+        File.open(File.join(@ctx.root, '.gitignore'), 'a') { |f| f.write('.env') }
+
+        @ctx.puts(@ctx.message('rails.create.adding_shopify_gem'))
+        File.open(File.join(@ctx.root, 'Gemfile'), 'a') do |f|
+          f.puts "\ngem 'shopify_app', '>=11.3.0'"
+        end
+        CLI::UI::Frame.open(@ctx.message('rails.create.running_bundle_install')) do
+          syscall(%w(bundle install))
+        end
+
+        CLI::UI::Frame.open(@ctx.message('rails.create.running_generator')) do
+          begin
+            syscall(%w(spring stop))
+          rescue
+          end
+          syscall(%w(rails generate shopify_app))
+        end
+
+        CLI::UI::Frame.open(@ctx.message('rails.create.running_migrations')) do
+          syscall(%w(rails db:create))
+          syscall(%w(rails db:migrate RAILS_ENV=development))
+        end
+      end
+
+      def set_custom_ua
+        ua_path = File.join('config', 'initializers', 'user_agent.rb')
+        @ctx.write(ua_path, USER_AGENT_CODE)
+      end
+
+      def syscall(args)
+        args[0] = Gem.binary_path_for(@ctx, args[0])
+        @ctx.system(*args, chdir: @ctx.root)
+      end
+
+      def install_gem(name, version = nil)
+        Gem.install(@ctx, name, version)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Rails
+  module Commands
+    class Deploy < ShopifyCli::Command
+      subcommand :Heroku, 'heroku', Project.project_filepath('commands/deploy/heroku')
+
+      def call(*)
+        @ctx.puts(self.class.help)
+      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/deploy/heroku.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Rails
+  module Commands
+    class Deploy
+      class Heroku < ShopifyCli::SubCommand
+        DB_CHECK_CMD = 'bundle exec rails runner "puts ActiveRecord::Base.connection.adapter_name.downcase"'
+
+        def self.help
+          ShopifyCli::Context.message('rails.deploy.heroku.help', ShopifyCli::TOOL_NAME)
+        end
+
+        def call(*)
+          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

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module Rails
+  module Commands
+    class Generate < ShopifyCli::Command
+      subcommand :Webhook, 'webhook', Project.project_filepath('commands/generate/webhook')
+
+      def call(*)
+        @ctx.puts(self.class.help)
+      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)
+        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/generate/webhook.rb

@@ -0,0 +1,39 @@
+require 'shopify_cli'
+require 'json'
+module Rails
+  module Commands
+    class Generate
+      class Webhook < ShopifyCli::SubCommand
+        def call(args, _name)
+          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::Commands::Generate.run_generate(generate_command(selected_type), selected_type, @ctx)
+            spinner.update_title("{{green:#{selected_type}}} config/initializers/shopify_app.rb")
+          end
+          spin_group.wait
+        end
+
+        def self.help
+          ShopifyCli::Context.message('rails.generate.webhook.help', ShopifyCli::TOOL_NAME)
+        end
+
+        def generate_command(selected_type)
+          parts = selected_type.downcase.split("_")
+          env = ShopifyCli::Project.current.env.host
+          selected_type = parts[0..-2].join("_") + "/" + parts[-1]
+          "rails g shopify_app:add_webhook -t #{selected_type} -a #{env}/webhooks/#{selected_type.downcase}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'shopify_cli'
+
+module Rails
+  module Commands
+    class Open < ShopifyCli::Command
+      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/populate.rb

@@ -0,0 +1,23 @@
+require 'shopify_cli'
+
+module Rails
+  module Commands
+    class Populate < ShopifyCli::Command
+      subcommand :Product, 'products', Project.project_filepath('commands/populate/product')
+      subcommand :Customer, 'customers', Project.project_filepath('commands/populate/customer')
+      subcommand :DraftOrder, 'draftorders', Project.project_filepath('commands/populate/draft_order')
+
+      def call(_args, _name)
+        @ctx.puts(self.class.help)
+      end
+
+      def self.help
+        ShopifyCli::Context.message('rails.populate.help', ShopifyCli::TOOL_NAME)
+      end
+
+      def self.extended_help
+        ShopifyCli::Context.message('rails.populate.extended_help', ShopifyCli::TOOL_NAME)
+      end
+    end
+  end
+end

data/lib/project_types/rails/commands/populate/customer.rb

@@ -0,0 +1,31 @@
+require 'shopify_cli'
+
+module Rails
+  module Commands
+    class Populate
+      class Customer < ShopifyCli::AdminAPI::PopulateResourceCommand
+        @input_type = :CustomerInput
+
+        def defaults
+          first_name, last_name = ShopifyCli::Helpers::Haikunator.name
+          {
+            firstName: first_name,
+            lastName: last_name,
+          }
+        end
+
+        def message(data)
+          ret = data['customerCreate']['customer']
+          id = ShopifyCli::API.gid_to_id(ret['id'])
+          @ctx.message(
+            'rails.populate.customer.added',
+            ret['displayName'],
+            ShopifyCli::Project.current.env.shop,
+            admin_url,
+            id
+          )
+        end
+      end
+    end
+  end
+end