shopify-cli 0.9.0

data/lib/shopify-cli/core.rb

@@ -0,0 +1,9 @@
+module ShopifyCli
+  module Core
+    autoload :EntryPoint, 'shopify-cli/core/entry_point'
+    autoload :Executor, 'shopify-cli/core/executor'
+    autoload :HelpResolver, 'shopify-cli/core/help_resolver'
+    autoload :Monorail, 'shopify-cli/core/monorail'
+    autoload :Update, 'shopify-cli/core/update'
+  end
+end

data/lib/shopify-cli/core/entry_point.rb

@@ -0,0 +1,40 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Core
+    module EntryPoint
+      class << self
+        def call(args, ctx = Context.new)
+          # Check if the shim is set up by checking whether the old Finalizer FD exists
+          begin
+            is_shell_shim = false
+            IO.open(9) { is_shell_shim = true }
+          rescue Errno::EBADF
+            # This is expected if the descriptor doesn't exist
+          end
+
+          if !ctx.testing? && is_shell_shim
+            ctx.puts(ctx.message('core.warning.shell_shim'))
+            return
+          end
+
+          if ctx.development?
+            ctx.puts(
+              ctx.message('core.warning.development_version', File.join(ShopifyCli::ROOT, 'bin', ShopifyCli::TOOL_NAME))
+            )
+          end
+
+          ProjectType.load_type(Project.current_project_type)
+
+          task_registry = ShopifyCli::Tasks::Registry
+
+          command, command_name, args = ShopifyCli::Resolver.call(args)
+          executor = ShopifyCli::Core::Executor.new(ctx, task_registry, log_file: ShopifyCli::LOG_FILE)
+          ShopifyCli::Core::Monorail.log(command_name, args) do
+            executor.call(command, command_name, args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/core/executor.rb

@@ -0,0 +1,21 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  module Core
+    class Executor < CLI::Kit::Executor
+      def initialize(ctx, task_registry, *args)
+        @ctx = ctx || ShopifyCli::Context.new
+        @task_registry = task_registry || ShopifyCli::Tasks::TaskRegistry.new
+        super(*args)
+      end
+
+      def call(command, command_name, args)
+        command.prerequisite_tasks.each do |task, _|
+          @task_registry[task]&.call(@ctx)
+        end
+        command.ctx = @ctx
+        super
+      end
+    end
+  end
+end

data/lib/shopify-cli/core/help_resolver.rb

@@ -0,0 +1,20 @@
+require 'cli/kit'
+
+module ShopifyCli
+  module Core
+    class HelpResolver < CLI::Kit::Resolver
+      def call(args)
+        args = args.dup
+        return super(args) unless args.first
+        if args.first.include?('-h') || args.first.include?('--help')
+          help = Commands::Help
+          help.ctx = Context.new
+          help.call([], nil)
+          raise ShopifyCli::AbortSilent
+        else
+          super(args)
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/core/monorail.rb

@@ -0,0 +1,118 @@
+require 'json'
+require 'net/http'
+require 'time'
+require 'rbconfig'
+
+module ShopifyCli
+  module Core
+    module Monorail
+      ENDPOINT_URI = URI.parse('https://monorail-edge.shopifycloud.com/v1/produce')
+      INVOCATIONS_SCHEMA = 'app_cli_command/4.0'
+
+      # Extra hash of data that will be sent in the payload
+      @metadata = {}
+
+      class << self
+        attr_accessor :metadata
+
+        def log(name, args, &block) # rubocop:disable Lint/UnusedMethodArgument
+          prompt_for_consent
+          return yield unless enabled? && consented?
+
+          command, command_name = Commands::Registry.lookup_command(name)
+          final_command = [command_name]
+          if command
+            subcommand, subcommand_name = command.subcommand_registry.lookup_command(args.first)
+            final_command << subcommand_name if subcommand
+          end
+
+          start_time = now_in_milliseconds
+          err = nil
+          begin
+            yield
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            err = e
+            raise
+          ensure
+            send_event(start_time, final_command, args - final_command, err&.message)
+          end
+        end
+
+        private
+
+        def now_in_milliseconds
+          (Time.now.utc.to_f * 1000).to_i
+        end
+
+        # we only want to send Monorail events in production or when explicitly developing
+        def enabled?
+          Context.new.system? || ENV['MONORAIL_REAL_EVENTS'] == '1'
+        end
+
+        def consented?
+          ShopifyCli::Config.get_bool('analytics', 'enabled')
+        end
+
+        def prompt_for_consent
+          return unless enabled?
+          return if ShopifyCli::Config.get_section('analytics').key?('enabled')
+          msg = Context.message('core.monorail.consent_prompt')
+          opt = CLI::UI::Prompt.confirm(msg)
+          ShopifyCli::Config.set('analytics', 'enabled', opt)
+        end
+
+        def send_event(start_time, commands, args, err = nil)
+          end_time = now_in_milliseconds
+          headers = {
+            'Content-Type': 'application/json; charset=utf-8',
+            'X-Monorail-Edge-Event-Created-At-Ms': start_time.to_s,
+            'X-Monorail-Edge-Event-Sent-At-Ms': end_time.to_s,
+          }
+          begin
+            Net::HTTP.start(
+              ENDPOINT_URI.host,
+              ENDPOINT_URI.port,
+              # timeouts for opening a connection, reading, writing (in seconds)
+              open_timeout: 0.2, read_timeout: 0.2, write_timeout: 0.2,
+              use_ssl: ENDPOINT_URI.scheme == 'https'
+            ) do |http|
+              payload = build_payload(start_time, end_time, commands, args, err)
+              post = Net::HTTP::Post.new(ENDPOINT_URI.request_uri, headers)
+              post.body = JSON.dump(payload)
+              http.request(post)
+            end
+          rescue
+            # silently fail on errors, fire-and-forget approach
+          end
+        end
+
+        def build_payload(start_time, end_time, commands, args, err = nil)
+          {
+            schema_id: INVOCATIONS_SCHEMA,
+            payload: {
+              project_type: Project.current_project_type.to_s,
+              command: commands.join(' '),
+              args: args.join(' '),
+              time_start: start_time,
+              time_end: end_time,
+              total_time: end_time - start_time,
+              success: err.nil?,
+              error_message: err,
+              uname: RbConfig::CONFIG["host"],
+              cli_version: ShopifyCli::Git.sha(dir: ShopifyCli::ROOT),
+              ruby_version: RUBY_VERSION,
+            }.tap do |payload|
+              payload[:metadata] = JSON.dump(metadata) unless metadata.empty?
+
+              if Project.has_current?
+                project = Project.current
+                payload[:api_key] = project.env&.api_key
+                payload[:partner_id] = project.config['organization_id']
+              end
+            end,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/db.rb

@@ -0,0 +1,114 @@
+require 'pstore'
+require 'forwardable'
+
+module ShopifyCli
+  # Persists transient data like access tokens that may be cleared
+  # when user clears their session
+  #
+  # All of the instance methods documented here can be used as class methods. All class
+  # methods are forwarded to a new instance of the database, pointing at the default
+  # path.
+  class DB
+    extend SingleForwardable
+    def_delegators :new, :keys, :exists?, :set, :get, :del, :clear
+
+    attr_reader :db # :nodoc:
+
+    def initialize(path: File.join(ShopifyCli::CACHE_DIR, ".db.pstore")) # :nodoc:
+      @db = PStore.new(path)
+    end
+
+    # Get all keys that exist in the database.
+    #
+    # #### Returns
+    # - `keys`: an array of string or symbol keys that exist in the database
+    #
+    # #### Usage
+    #
+    #   ShopifyCli::DB.keys
+    #
+    def keys
+      db.transaction(true) { db.roots }
+    end
+
+    # Check to see if a key exists in the database, the key will only exist if it
+    # has a value so if the key exists then there is also a value.
+    #
+    # #### Parameters
+    # - `key`: a string or a symbol representation of a key that is stored in the DB
+    #
+    # #### Returns
+    # - `exists`: a boolean value if the key exists in the database
+    #
+    # #### Usage
+    #
+    #   exists = ShopifyCli::DB.exists?('admin_access_token')
+    #
+    def exists?(key)
+      db.transaction(true) { db.root?(key) }
+    end
+
+    # Persist a value by key in the local storage
+    #
+    # #### Parameters
+    # - `**args`: a hash of keys and values to persist in the database
+    #
+    # #### Usage
+    #
+    #   ShopifyCli::DB.set(admin_access_token: 'token', metric_consent: true)
+    #
+    def set(**args)
+      db.transaction do
+        args.each do |key, val|
+          if val.nil?
+            db.delete(key)
+          else
+            db[key] = val
+          end
+        end
+      end
+    end
+
+    # Gets a value from the DB that is associated with the supplied key
+    #
+    # #### Parameters
+    # - `key`: a string or a symbol representation of a key that is stored in the DB
+    #
+    # #### Returns
+    # - `value`: will be the previously saved value or nil if the key does not exist
+    #   in the database.
+    #
+    # #### Usage
+    #
+    #   ShopifyCli::DB.get(:admin_access_token)
+    #
+    def get(key)
+      val = db.transaction(true) { db[key] }
+      val = yield if val.nil? && block_given?
+      val
+    end
+
+    # Deletes a value from the local storage
+    #
+    # #### Parameters
+    # - `*args`: an array of strings or symbols that are keys to be removed from the database
+    #
+    # #### Usage
+    #
+    #   ShopifyCli::DB.del(:admin_access_token)
+    #
+    def del(*args)
+      db.transaction { args.each { |key| db.delete(key) } }
+    end
+
+    # Drops all keys from the database.
+    #
+    # #### Usage
+    #
+    #   ShopifyCli::DB.clear
+    #
+    def clear
+      del(*keys)
+    end
+  end
+end

data/lib/shopify-cli/form.rb

@@ -0,0 +1,40 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  class Form
+    class << self
+      def ask(ctx, args, flags)
+        attrs = {}
+        (@positional_arguments || []).each { |name| attrs[name] = args.shift }
+        return nil if attrs.any? { |_k, v| v.nil? }
+        (@flag_arguments || []).each { |arg| attrs[arg] = flags[arg] }
+        form = new(ctx, args, attrs)
+        begin
+          form.ask
+          form
+        rescue ShopifyCli::Abort => err
+          ctx.puts(err.message)
+          nil
+        end
+      end
+
+      def positional_arguments(*args)
+        @positional_arguments = args
+        attr_accessor(*args)
+      end
+
+      def flag_arguments(*args)
+        @flag_arguments = args
+        attr_accessor(*args)
+      end
+    end
+
+    attr_accessor :ctx, :xargs
+
+    def initialize(ctx, xargs, attributes)
+      @ctx = ctx
+      @xargs = xargs
+      attributes.each { |k, v| send("#{k}=", v) unless v.nil? }
+    end
+  end
+end

data/lib/shopify-cli/git.rb

@@ -0,0 +1,141 @@
+module ShopifyCli
+  ##
+  # ShopifyCli::Git wraps git functionality to make it easier to integrate will
+  # git.
+  class Git
+    class << self
+      ##
+      # will return the current sha of the cli repo
+      #
+      # #### Parameters
+      #
+      # * `dir` - the directory of the git repo. This defaults to the cli repo
+      # * `ctx` - the current running context of your command
+      #
+      # #### Returns
+      #
+      # * `sha_string` - string of the sha of the most recent commit to the repo
+      #
+      # #### Example
+      #
+      #   ShopifyCli::Git.sha
+      #
+      def sha(dir: Dir.pwd, ctx: Context.new)
+        rev_parse('HEAD', dir: dir, ctx: ctx)
+      end
+
+      ##
+      # will make calls to git to clone a new repo into a supplied destination,
+      # it will also output progress of the cloning process.
+      #
+      # #### Parameters
+      #
+      # * `repository` - a git url for git to clone the repo from
+      # * `dest` - a filepath to where the repo should be cloned to
+      # * `ctx` - the current running context of your command, defaults to a new context.
+      #
+      # #### Returns
+      #
+      # * `sha_string` - string of the sha of the most recent commit to the repo
+      #
+      # #### Example
+      #
+      #   ShopifyCli::Git.clone('git@github.com:shopify/test.git', 'test-app')
+      #
+      def clone(repository, dest, ctx: Context.new)
+        if Dir.exist?(dest)
+          ctx.abort(ctx.message('core.git.error.directory_exists'))
+        else
+          CLI::UI::Frame.open(ctx.message('core.git.cloning', dest)) do
+            clone_progress('clone', '--single-branch', repository, dest, ctx: ctx)
+          end
+          ctx.done(ctx.message('core.git.cloned', dest))
+        end
+      end
+
+      ##
+      # will fetch the repos list of branches.
+      #
+      # #### Parameters
+      #
+      # * `ctx` - the current running context of your command, defaults to a new context.
+      #
+      # #### Returns
+      #
+      # * `branches` - [String] an array of strings that are branch names
+      #
+      # #### Example
+      #
+      #   branches = ShopifyCli::Git.branches(@ctx)
+      #
+      def branches(ctx)
+        output, status = ctx.capture2e('git', 'branch', '--list', '--format=%(refname:short)')
+        ctx.abort(ctx.message('core.git.error.no_branches_found')) unless status.success?
+
+        branches = if output == ''
+          ['master']
+        else
+          output.split("\n")
+        end
+
+        branches
+      end
+
+      ##
+      # will initialize a new repo in the current directory. This will output
+      # if it was successful or not.
+      #
+      # #### Parameters
+      #
+      # * `ctx` - the current running context of your command, defaults to a new context.
+      #
+      # #### Example
+      #
+      #   ShopifyCli::Git.init(@ctx)
+      #
+      def init(ctx)
+        output, status = ctx.capture2e('git', 'status')
+
+        unless status.success?
+          ctx.abort(ctx.message('core.git.error.repo_not_initiated'))
+        end
+
+        if output.include?('No commits yet')
+          ctx.abort(ctx.message('core.git.error.no_commits_made'))
+        end
+      end
+
+      private
+
+      def exec(*args, dir: Dir.pwd, default: nil, ctx: Context.new)
+        args = %w(git) + args
+        out, _, stat = ctx.capture3(*args, chdir: dir)
+        return default unless stat.success?
+        out.chomp
+      end
+
+      def rev_parse(*args, dir: nil, ctx: Context.new)
+        exec('rev-parse', *args, dir: dir, ctx: ctx)
+      end
+
+      def clone_progress(*git_command, ctx:)
+        CLI::UI::Progress.progress do |bar|
+          msg = []
+          success = ctx.system('git', *git_command, '--progress') do |_out, err|
+            if err.strip.start_with?('Receiving objects:')
+              percent = (err.match(/Receiving objects:\s+(\d+)/)[1].to_f / 100).round(2)
+              bar.tick(set_percent: percent)
+              next
+            end
+            msg << err
+          end.success?
+          unless success
+            ctx.abort(msg.join("\n"))
+          end
+          bar.tick(set_percent: 1.0)
+          true
+        end
+      end
+    end
+  end
+end