shopify-cli 0.9.0

data/lib/shopify-cli/resources.rb

@@ -0,0 +1,5 @@
+module ShopifyCli
+  module Resources
+    autoload :EnvFile, 'shopify-cli/resources/env_file'
+  end
+end

data/lib/shopify-cli/resources/env_file.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ShopifyCli
+  module Resources
+    class EnvFile
+      include SmartProperties
+      FILENAME = '.env'
+      KEY_MAP = {
+        'SHOPIFY_API_KEY' => :api_key,
+        'SHOPIFY_API_SECRET' => :secret,
+        'SHOP' => :shop,
+        'SCOPES' => :scopes,
+        'HOST' => :host,
+      }
+
+      class << self
+        def read(_directory = Dir.pwd)
+          input = parse_external_env
+          new(input)
+        end
+
+        def parse(directory)
+          File.read(File.join(directory, FILENAME))
+            .gsub("\r\n", "\n").split("\n").each_with_object({}) do |line, output|
+            match = /\A([A-Za-z_0-9]+)=(.*)\z/.match(line)
+            if match
+              key = match[1]
+              output[key] = case match[2]
+              # Remove single quotes
+              when /\A'(.*)'\z/ then match[2]
+              # Remove double quotes and unescape string preserving newline characters
+              when /\A"(.*)"\z/ then match[2].gsub('\n', "\n").gsub(/\\(.)/, '\1')
+              else match[2]
+              end
+            end
+            output
+          end
+        end
+
+        def parse_external_env(directory = Dir.pwd)
+          env_details = {}
+          extra = {}
+          parse(directory).each do |key, value|
+            if KEY_MAP[key]
+              env_details[KEY_MAP[key]] = value
+            else
+              extra[key] = value
+            end
+          end
+          env_details[:extra] = extra
+          env_details
+        end
+      end
+
+      property :api_key, required: true
+      property :secret, required: true
+      property :shop
+      property :scopes
+      property :host
+      property :extra, default: {}
+
+      def to_h
+        out = {}
+        KEY_MAP.each do |key, value|
+          out[key] = send(value).to_s if send(value)
+        end
+        extra.each do |key, value|
+          out[key] = value.to_s
+        end
+        out
+      end
+
+      def write(ctx)
+        spin_group = CLI::UI::SpinGroup.new
+        spin_group.add(ctx.message('core.env_file.saving_header', FILENAME)) do |spinner|
+          output = []
+          KEY_MAP.each do |key, value|
+            output << "#{key}=#{send(value)}" if send(value)
+          end
+          extra.each do |key, value|
+            output << "#{key}=#{value}"
+          end
+          ctx.print_task(ctx.message('core.env_file.saving', FILENAME))
+          ctx.write(FILENAME, output.join("\n") + "\n")
+          spinner.update_title(ctx.message('core.env_file.saved', FILENAME))
+        end
+        spin_group.wait
+      end
+
+      def update(ctx, field, value)
+        self[field] = value
+        write(ctx)
+      end
+    end
+  end
+end

data/lib/shopify-cli/sub_command.rb

@@ -0,0 +1,15 @@
+# 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
+        cmd.call(args, command_name)
+      end
+    end
+  end
+end

data/lib/shopify-cli/task.rb

@@ -0,0 +1,10 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  class Task
+    def self.call(*args)
+      task = new
+      task.call(*args)
+    end
+  end
+end

data/lib/shopify-cli/tasks.rb

@@ -0,0 +1,32 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Tasks
+    class TaskRegistry
+      def initialize
+        @tasks = {}
+      end
+
+      def add(const, name)
+        @tasks[name] = const
+      end
+
+      def [](name)
+        @tasks[name]
+      end
+    end
+
+    Registry = TaskRegistry.new
+
+    def self.register(task, name, path)
+      autoload(task, path)
+      Registry.add(const_get(task), name)
+    end
+
+    register :CreateApiClient, :create_api_client, 'shopify-cli/tasks/create_api_client'
+    register :EnsureEnv, :ensure_env, 'shopify-cli/tasks/ensure_env'
+    register :EnsureLoopbackURL, :ensure_loopback_url, 'shopify-cli/tasks/ensure_loopback_url'
+    register :EnsureDevStore, :ensure_dev_store, 'shopify-cli/tasks/ensure_dev_store'
+    register :UpdateDashboardURLS, :update_dashboard_urls, 'shopify-cli/tasks/update_dashboard_urls'
+  end
+end

data/lib/shopify-cli/tasks/create_api_client.rb

@@ -0,0 +1,29 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Tasks
+    class CreateApiClient < ShopifyCli::Task
+      VALID_APP_TYPES = %w(public custom)
+      DEFAULT_APP_URL = 'https://shopify.github.io/shopify-app-cli/help/start-app/'
+
+      def call(ctx, org_id:, title:, type:)
+        resp = ShopifyCli::PartnersAPI.query(
+          ctx,
+          'create_app',
+          org: org_id.to_i,
+          title: title,
+          type: type,
+          app_url: DEFAULT_APP_URL,
+          redir: [OAuth::REDIRECT_HOST]
+        )
+
+        user_errors = resp["data"]["appCreate"]["userErrors"]
+        if !user_errors.nil? && user_errors.any?
+          ctx.abort(user_errors.map { |err| "#{err['field']} #{err['message']}" }.join(", "))
+        end
+
+        resp["data"]["appCreate"]["app"]
+      end
+    end
+  end
+end

data/lib/shopify-cli/tasks/ensure_dev_store.rb

@@ -0,0 +1,41 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Tasks
+    class EnsureDevStore < ShopifyCli::Task
+      def call(ctx)
+        @ctx = ctx
+        return ctx.puts(ctx.message(
+          'core.tasks.ensure_dev_store.could_not_verify_store', project.env.shop
+        )) if shop.nil?
+        return if shop['transferDisabled'] == true
+        return unless CLI::UI::Prompt.confirm(
+          ctx.message('core.tasks.ensure_dev_store.convert_to_dev_store', project.env.shop)
+        )
+        ShopifyCli::PartnersAPI.query(ctx, 'convert_dev_to_test_store', input: {
+          organizationID: shop['orgID'].to_i,
+          shopId: shop['shopId'],
+        })
+        ctx.puts(ctx.message('core.tasks.ensure_dev_store.transfer_disabled', project.env.shop))
+      end
+
+      private
+
+      def project
+        @project ||= ShopifyCli::Project.current
+      end
+
+      def shop
+        @shop ||= begin
+          current_domain = project.env.shop
+          ShopifyCli::PartnersAPI::Organizations.fetch_all(@ctx).map do |org|
+            org['stores'].find do |store|
+              store['orgID'] = org['id']
+              store['shopDomain'] == current_domain
+            end
+          end.compact.first
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/tasks/ensure_env.rb

@@ -0,0 +1,31 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Tasks
+    class EnsureEnv < ShopifyCli::Task
+      def call(ctx)
+        @ctx = ctx
+        Resources::EnvFile.read(ctx.root)
+      rescue Errno::ENOENT
+        ask
+      end
+
+      def ask
+        api_key = CLI::UI.ask(@ctx.message('core.tasks.ensure_env.api_key_question'))
+        api_secret = CLI::UI.ask(@ctx.message('core.tasks.ensure_env.api_secret_key_question'))
+        shop = CLI::UI.ask(@ctx.message('core.tasks.ensure_env.development_store_question'))
+
+        shop.gsub!(/https?\:\/\//, '')
+
+        env = Resources::EnvFile.new(
+          api_key: api_key,
+          secret: api_secret,
+          shop: shop,
+          host: ShopifyCli::Tunnel.start(@ctx),
+          scopes: 'write_products,write_customers,write_draft_orders',
+        ).write(@ctx)
+        env
+      end
+    end
+  end
+end

data/lib/shopify-cli/tasks/ensure_loopback_url.rb

@@ -0,0 +1,20 @@
+module ShopifyCli
+  module Tasks
+    class EnsureLoopbackURL < ShopifyCli::Task
+      def call(ctx)
+        @ctx = ctx
+        api_key = Project.current.env.api_key
+        result = ShopifyCli::PartnersAPI.query(ctx, 'get_app_urls', apiKey: api_key)
+        loopback = OAuth::REDIRECT_HOST
+        app = result['data']['app']
+        urls = app['redirectUrlWhitelist']
+        if urls.grep(/#{loopback}/).empty?
+          with_loopback = urls.push(loopback)
+          ShopifyCli::PartnersAPI.query(@ctx, 'update_dashboard_urls', input: {
+            redirectUrlWhitelist: with_loopback, apiKey: api_key
+          })
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/tasks/update_dashboard_urls.rb

@@ -0,0 +1,44 @@
+module ShopifyCli
+  module Tasks
+    class UpdateDashboardURLS < ShopifyCli::Task
+      NGROK_REGEX = /https:\/\/([a-z0-9\-]+\.ngrok\.io)(.*)/
+
+      def call(ctx, url:, callback_url:)
+        @ctx = ctx
+        project = ShopifyCli::Project.current
+        api_key = project.env.api_key
+        result = ShopifyCli::PartnersAPI.query(ctx, 'get_app_urls', apiKey: api_key)
+        app = result['data']['app']
+        consent = check_application_url(app['applicationUrl'], url)
+        constructed_urls = construct_redirect_urls(app['redirectUrlWhitelist'], url, callback_url)
+        return if url == app['applicationUrl']
+        ShopifyCli::PartnersAPI.query(@ctx, 'update_dashboard_urls', input: {
+          applicationUrl: consent ? url : app['applicationUrl'],
+          redirectUrlWhitelist: constructed_urls, apiKey: api_key
+        })
+        @ctx.puts(@ctx.message('core.tasks.update_dashboard_urls.updated'))
+      rescue
+        @ctx.puts(@ctx.message('core.tasks.update_dashboard_urls.update_error', ShopifyCli::TOOL_NAME))
+        raise
+      end
+
+      def check_application_url(application_url, new_url)
+        return false if application_url.match(new_url)
+        CLI::UI::Prompt.confirm(@ctx.message('core.tasks.update_dashboard_urls.update_prompt'))
+      end
+
+      def construct_redirect_urls(urls, new_url, callback_url)
+        urls.map do |url|
+          if (match = url.match(NGROK_REGEX))
+            "#{new_url}#{match[2]}"
+          else
+            url
+          end
+        end
+        if urls.grep(/#{new_url}#{callback_url}/).empty?
+          urls.push("#{new_url}#{callback_url}")
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/tunnel.rb

@@ -0,0 +1,154 @@
+require 'json'
+require 'fileutils'
+require 'shopify_cli'
+require 'forwardable'
+
+module ShopifyCli
+  ##
+  # Wraps around ngrok functionality to allow you to spawn a ngrok proccess in the
+  # background and stop the process when you need to. It also allows control over
+  # the ngrok process between application runs.
+  class Tunnel
+    extend SingleForwardable
+
+    def_delegators :new, :start, :stop, :auth
+
+    class FetchUrlError < RuntimeError; end
+    class NgrokError < RuntimeError; end
+
+    PORT = 8081 # port that ngrok will bind to
+    # mapping for supported operating systems for where to download ngrok from.
+    DOWNLOAD_URLS = {
+      mac: 'https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-darwin-amd64.zip',
+      linux: 'https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip',
+    }
+
+    ##
+    # will find and stop a running tunnel process. It will also output if the
+    # operation was successful or not
+    #
+    # #### Paramters
+    #
+    # * `ctx` - running context from your command
+    #
+    def stop(ctx)
+      if ShopifyCli::ProcessSupervision.running?(:ngrok)
+        if ShopifyCli::ProcessSupervision.stop(:ngrok)
+          ctx.puts(ctx.message('core.tunnel.stopped'))
+        else
+          ctx.abort(ctx.message('core.tunnel.error.stop'))
+        end
+      else
+        ctx.puts(ctx.message('core.tunnel.not_running'))
+      end
+    end
+
+    ##
+    # start will start a running ngrok process running in the background. It will
+    # also output the success of this operation
+    #
+    # #### Paramters
+    #
+    # * `ctx` - running context from your command
+    # * `port` - port to use to open the ngrok tunnel
+    #
+    # #### Returns
+    #
+    # * `url` - the url that the tunnel is now bound to and available to the public
+    #
+    def start(ctx, port: PORT)
+      install(ctx)
+      process = ShopifyCli::ProcessSupervision.start(:ngrok, ngrok_command(port))
+      log = fetch_url(ctx, process.log_path)
+      if log.account
+        ctx.puts(ctx.message('core.tunnel.start_with_account', log.url, log.account))
+      else
+        ctx.puts(ctx.message('core.tunnel.start', log.url))
+      end
+      log.url
+    end
+
+    ##
+    # will add the users authentication token to our version of ngrok to unlock the
+    # extended ngrok features
+    #
+    # #### Paramters
+    #
+    # * `ctx` - running context from your command
+    # * `token` - authentication token provided by ngrok for extended features
+    #
+    def auth(ctx, token)
+      install(ctx)
+      ctx.system(File.join(ShopifyCli::CACHE_DIR, 'ngrok'), 'authtoken', token)
+    end
+
+    private
+
+    def install(ctx)
+      return if File.exist?(File.join(ShopifyCli::CACHE_DIR, 'ngrok'))
+      spinner = CLI::UI::SpinGroup.new
+      spinner.add('Installing ngrok...') do
+        zip_dest = File.join(ShopifyCli::CACHE_DIR, 'ngrok.zip')
+        unless File.exist?(zip_dest)
+          ctx.system('curl', '-o', zip_dest, DOWNLOAD_URLS[ctx.os], chdir: ShopifyCli::CACHE_DIR)
+        end
+        ctx.system('unzip', '-u', zip_dest, chdir: ShopifyCli::CACHE_DIR)
+        ctx.rm(zip_dest)
+      end
+      spinner.wait
+    end
+
+    def fetch_url(ctx, log_path)
+      LogParser.new(log_path)
+    rescue RuntimeError => e
+      stop(ctx)
+      raise e.class, e.message
+    end
+
+    def ngrok_command(port)
+      "exec #{File.join(ShopifyCli::CACHE_DIR, 'ngrok')} http -log=stdout -log-level=debug #{port}"
+    end
+
+    class LogParser # :nodoc:
+      TIMEOUT = 10
+
+      attr_reader :url, :account
+
+      def initialize(log_path)
+        @log_path = log_path
+        counter = 0
+        while counter < TIMEOUT
+          parse
+          return if url
+          counter += 1
+          sleep(1)
+        end
+
+        raise FetchUrlError, Context.message('core.tunnel.error.url_fetch_failure') unless url
+      end
+
+      def parse
+        @log = File.read(@log_path)
+        unless error.empty?
+          raise NgrokError, error.first
+        end
+        parse_account
+        parse_url
+      end
+
+      def parse_url
+        @url, _ = @log.match(/msg="started tunnel".*url=(https:\/\/.+)/)&.captures
+      end
+
+      def parse_account
+        @account, _ = @log.match(/AccountName:([\w\s]+) SessionDuration/)&.captures
+      end
+
+      def error
+        @log.scan(/msg="command failed" err="([^"]+)"/).flatten
+      end
+    end
+
+    private_constant :LogParser
+  end
+end