shopify-cli 0.9.0

data/lib/project_types/script/ui/strict_spinner.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'shopify_cli'
+
+module Script
+  module UI
+    module StrictSpinner
+      def self.spin(title, auto_debrief: false)
+        exception = nil
+        CLI::UI::Spinner.spin(title, auto_debrief: auto_debrief) do |*args|
+          begin
+            yield(*args)
+          rescue StandardError => e
+            exception = e
+            CLI::UI::Spinner::TASK_FAILED
+          end
+        end
+        raise exception if exception
+      end
+    end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,18 @@
+Gem.post_uninstall do |uninstaller|
+  if uninstaller.spec.name == 'shopify-cli'
+    require 'fileutils'
+
+    symlink = '/usr/local/bin/shopify'
+
+    # delete the symbolic link IFF it exists AND it does not point to a file
+    # (i.e., it's been left hanging as a result of the uninstall, as expected)
+    #
+    # if the file still exists, either the uninstall failed (possible but
+    # unlikely) OR
+    # there's another installation of the gem in another ruby folder that has
+    # overwritten it, so leave the symbolic link alone
+    system("sudo rm -f #{symlink}") if File.symlink?(symlink) && !File.exist?(symlink)
+  end
+
+  true
+end

data/lib/shopify-cli/admin_api.rb

@@ -0,0 +1,99 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  ##
+  # ShopifyCli::AdminAPI wraps our graphql functionality with authentication so that
+  # these concerns are taken care of.
+  #
+  class AdminAPI < API
+    autoload :PopulateResourceCommand, 'shopify-cli/admin_api/populate_resource_command'
+    autoload :Schema, 'shopify-cli/admin_api/schema'
+
+    class << self
+      ##
+      # issues a graphql query or mutation to the Shopify Admin API. It loads a graphql
+      # query from a file so that you do not need to use large unwieldy query strings.
+      #
+      # #### Parameters
+      # - `ctx`: running context from your command
+      # - `query_name`: name of the query you want to use, loaded from the `lib/graphql` directory.
+      # - `api_version`: an api version string to specify version. If no version is supplied then unstable will be used
+      # - `shop`: shop domain string for which shop that you are calling the admin
+      #   API on. If not supplied, then it will be fetched from the `.env` file
+      # - `**variable`: a hash of variables to be supplied to the query ro mutation
+      #
+      # #### Raises
+      #
+      # * http 404 will raise a ShopifyCli::API::APIRequestNotFoundError
+      # * http 400..499 will raise a ShopifyCli::API::APIRequestClientError
+      # * http 500..599 will raise a ShopifyCli::API::APIRequestServerError
+      # * All other codes will raise ShopifyCli::API::APIRequestUnexpectedError
+      #
+      # #### Returns
+      #
+      # * `resp` - graphql response data hash. This can be a different shape for every query.
+      #
+      # #### Example
+      #
+      #   ShopifyCli::AdminAPI.query(@ctx, 'all_organizations')
+      #
+      def query(ctx, query_name, api_version: nil, shop: nil, **variables)
+        shop ||= Project.current.env.shop
+        authenticated_req(ctx, shop) do
+          api_client(ctx, api_version, shop).query(query_name, variables: variables)
+        end
+      end
+
+      private
+
+      def authenticated_req(ctx, shop)
+        yield
+      rescue API::APIRequestUnauthorizedError
+        authenticate(ctx, shop)
+        retry
+      end
+
+      def authenticate(ctx, shop)
+        env = Project.current.env
+        ShopifyCli::OAuth.new(
+          ctx: ctx,
+          service: 'admin',
+          client_id: env.api_key,
+          secret: env.secret,
+          scopes: env.scopes,
+          token_path: "/access_token",
+          options: { 'grant_options[]' => 'per user' },
+        ).authenticate("https://#{shop}/admin/oauth")
+      end
+
+      def api_client(ctx, api_version, shop)
+        new(
+          ctx: ctx,
+          auth_header: 'X-Shopify-Access-Token',
+          token: admin_access_token(ctx, shop),
+          url: "https://#{shop}/admin/api/#{fetch_api_version(ctx, api_version, shop)}/graphql.json",
+        )
+      end
+
+      def admin_access_token(ctx, shop)
+        ShopifyCli::DB.get(:admin_access_token) do
+          authenticate(ctx, shop)
+          ShopifyCli::DB.get(:admin_access_token)
+        end
+      end
+
+      def fetch_api_version(ctx, api_version, shop)
+        return api_version unless api_version.nil?
+        client = new(
+          ctx: ctx,
+          auth_header: 'X-Shopify-Access-Token',
+          token: admin_access_token(ctx, shop),
+          url: "https://#{shop}/admin/api/unstable/graphql.json",
+        )
+        versions = client.query('api_versions')['data']['publicApiVersions']
+        latest = versions.find { |version| version['displayName'].include?('Latest') }
+        latest['handle']
+      end
+    end
+  end
+end

data/lib/shopify-cli/admin_api/populate_resource_command.rb

@@ -0,0 +1,165 @@
+require 'shopify_cli'
+require 'optparse'
+
+module ShopifyCli
+  class AdminAPI
+    class PopulateResourceCommand < ShopifyCli::SubCommand
+      DEFAULT_COUNT = 5
+
+      attr_reader :input
+
+      class << self
+        attr_accessor :input_type
+
+        # we override the call classmethod here because we parse options at runtime
+        def call(args, command_name, _parent_command)
+          cmd = new(@ctx)
+          cmd.call(args, command_name)
+        end
+
+        def help
+          cmd = new(@ctx)
+          output = cmd.display_parent_help + "\n"
+          output + cmd.display_parent_extended_help
+        end
+      end
+
+      def call(args, _)
+        return unless Project.current
+        Tasks::EnsureEnv.call(@ctx)
+        @args = args
+        @input = Hash.new
+        @count = DEFAULT_COUNT
+        @help = false
+        input_options
+        resource_options.parse(@args)
+
+        if @help
+          output = display_parent_extended_help
+          output += "\n#{@ctx.message('core.populate.options.header', camel_case_resource_type)}\n"
+          output += resource_options.help
+          return @ctx.puts(output)
+        end
+
+        if @silent
+          spin_group = CLI::UI::SpinGroup.new
+          spin_group.add(@ctx.message('core.populate.populating', @count, camel_case_resource_type)) do |spinner|
+            populate
+            spinner.update_title(completion_message)
+          end
+          spin_group.wait
+        else
+          populate
+          @ctx.puts(completion_message)
+        end
+      end
+
+      def message
+        raise NotImplementedError
+      end
+
+      def defaults
+        raise NotImplementedError
+      end
+
+      def display_parent_help
+        parent_command_klass.respond_to?(:help) ? parent_command_klass.help : ""
+      end
+
+      def display_parent_extended_help
+        parent_command_klass.respond_to?(:extended_help) ? parent_command_klass.extended_help : ""
+      end
+
+      def resource_options
+        @resource_options ||= OptionParser.new do |opts|
+          opts.banner = ""
+          opts.on(
+            "-c #{DEFAULT_COUNT}",
+            "--count=#{DEFAULT_COUNT}",
+            @ctx.message('core.populate.options.count_help')
+          ) do |value|
+            @count = value.to_i
+          end
+
+          opts.on('-h', '--help', 'print help') do |value|
+            @help = value
+          end
+
+          opts.on("--silent") { |v| @silent = v }
+
+          opts.on('--shop=', '-s') { |value| @shop = value }
+        end
+      end
+
+      def populate
+        @count.times do
+          run_mutation(defaults.merge(@input))
+        end
+      end
+
+      def input_options
+        schema.type(self.class.input_type)['inputFields'].each do |field|
+          resource_options.on(
+            "--#{field['name']}=#{field['defaultValue']}",
+            field['description']
+          ) do |value|
+            @input[field['name']] = value
+          end
+        end
+      end
+
+      def schema
+        @schema ||= AdminAPI::Schema.get(@ctx)
+      end
+
+      def run_mutation(data)
+        kwargs = { input: data }
+        kwargs[:shop] = @shop if @shop
+        resp = AdminAPI.query(
+          @ctx, "create_#{snake_case_resource_type}", kwargs
+        )
+        @ctx.abort(resp['errors']) if resp['errors']
+        @ctx.done(message(resp['data'])) unless @silent
+      end
+
+      def completion_message
+        plural = @count > 1 ? "s" : ""
+        @ctx.message(
+          'core.populate.completion_message',
+          @count,
+          "#{camel_case_resource_type}#{plural}",
+          Project.current.env.shop,
+          camel_case_resource_type,
+          admin_url,
+          snake_case_resource_type
+        )
+      end
+
+      def admin_url
+        "https://#{Project.current.env.shop}/admin/"
+      end
+
+      def price
+        format('%.2f', rand(1..10))
+      end
+
+      private
+
+      def camel_case_resource_type
+        @camel_case_resource_type ||= self.class.to_s.split('::').last
+      end
+
+      def snake_case_resource_type
+        @snake_case_resource_type ||= camel_case_resource_type.to_s
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr("-", "_")
+          .downcase
+      end
+
+      def parent_command_klass
+        @parent_command_klass ||= Module.const_get(self.class.to_s.split('::')[0..-2].join('::'))
+      end
+    end
+  end
+end

data/lib/shopify-cli/admin_api/schema.rb

@@ -0,0 +1,32 @@
+require 'shopify_cli'
+
+module ShopifyCli
+  class AdminAPI
+    class Schema < Hash
+      def self.get(ctx)
+        unless ShopifyCli::DB.exists?(:shopify_admin_schema)
+          schema = AdminAPI.query(ctx, 'admin_introspection')
+          ShopifyCli::DB.set(shopify_admin_schema: JSON.dump(schema))
+        end
+        # This is ruby magic for making a new hash with another hash.
+        # It wraps the JSON in our Schema Class to have the helper methods
+        # available
+        self[JSON.parse(ShopifyCli::DB.get(:shopify_admin_schema))]
+      end
+
+      def type(name)
+        data = self["data"]
+        schema = data["__schema"]
+        schema["types"].find do |object|
+          object['name'] == name.to_s
+        end
+      end
+
+      def get_names_from_type(name)
+        type(name)["enumValues"].map do |object|
+          object["name"]
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/api.rb

@@ -0,0 +1,104 @@
+require 'shopify_cli'
+require 'net/http'
+
+module ShopifyCli
+  class API
+    include SmartProperties
+
+    property! :ctx, accepts: ShopifyCli::Context
+    property! :token, accepts: String
+    property :auth_header, accepts: String
+    property! :url, accepts: String
+
+    class APIRequestError < StandardError; end
+    class APIRequestNotFoundError < APIRequestError; end
+    class APIRequestClientError < APIRequestError; end
+    class APIRequestUnauthorizedError < APIRequestClientError; end
+    class APIRequestUnexpectedError < APIRequestError; end
+    class APIRequestRetriableError < APIRequestError; end
+    class APIRequestServerError < APIRequestRetriableError; end
+    class APIRequestThrottledError < APIRequestRetriableError; end
+
+    def self.gid_to_id(gid)
+      gid.split('/').last
+    end
+
+    def query(query_name, variables: {})
+      _, resp = request(
+        load_query(query_name),
+        variables: variables,
+        headers: default_headers,
+        graphql_url: url,
+      )
+      ctx.debug(resp)
+      resp
+    end
+
+    protected
+
+    def load_query(name)
+      project_type = ShopifyCli::Project.current_project_type
+      project_file_path = File.join(
+        ShopifyCli::ROOT, 'lib', 'project_types', project_type.to_s, 'graphql', "#{name}.graphql"
+      )
+      if !project_type.nil? && File.exist?(project_file_path)
+        File.read(project_file_path)
+      else
+        File.read(File.join(ShopifyCli::ROOT, 'lib', 'graphql', "#{name}.graphql"))
+      end
+    end
+
+    private
+
+    def request(body, graphql_url:, variables: {}, headers: {})
+      CLI::Kit::Util.begin do
+        uri = URI.parse(graphql_url)
+        unless uri.is_a?(URI::HTTP)
+          ctx.abort("Invalid URL: #{graphql_url}")
+        end
+        http = ::Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        req = ::Net::HTTP::Post.new(uri.request_uri)
+        req.body = JSON.dump(query: body.tr("\n", ""), variables: variables)
+        req['Content-Type'] = 'application/json'
+        headers.each { |header, value| req[header] = value }
+        response = http.request(req)
+
+        case response.code.to_i
+        when 200..399
+          [response.code.to_i, JSON.parse(response.body)]
+        when 401
+          raise APIRequestUnauthorizedError, "#{response.code}\n#{response.body}"
+        when 404
+          raise APIRequestNotFoundError, "#{response.code}\n#{response.body}"
+        when 429
+          raise APIRequestThrottledError, "#{response.code}\n#{response.body}"
+        when 400..499
+          raise APIRequestClientError, "#{response.code}\n#{response.body}"
+        when 500..599
+          raise APIRequestServerError, "#{response.code}\n#{response.body}"
+        else
+          raise APIRequestUnexpectedError, "#{response.code}\n#{response.body}"
+        end
+      end.retry_after(APIRequestRetriableError, retries: 3) do |e|
+        sleep(1) if e.is_a?(APIRequestThrottledError)
+      end
+    end
+
+    def current_sha
+      @current_sha ||= Git.sha(dir: ShopifyCli::ROOT)
+    end
+
+    def default_headers
+      {
+        'User-Agent' => "Shopify App CLI #{ShopifyCli::VERSION} #{current_sha} | #{ctx.uname}",
+      }.merge(auth_headers(token))
+    end
+
+    def auth_headers(token)
+      raise NotImplementedError if auth_header.nil?
+      { auth_header => token }
+    end
+  end
+end

data/lib/shopify-cli/command.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module ShopifyCli
+  class Command < CLI::Kit::BaseCommand
+    attr_writer :ctx
+    attr_accessor :options
+
+    class << self
+      attr_writer :ctx
+      attr_reader :hidden
+
+      def call(args, command_name)
+        subcommand, resolved_name = subcommand_registry.lookup_command(args.first)
+        if subcommand
+          subcommand.ctx = @ctx
+          subcommand.call(args, resolved_name, command_name)
+        else
+          cmd = new(@ctx)
+          cmd.options.parse(@_options, args)
+          return call_help(command_name) if cmd.options.help
+          cmd.call(args, command_name)
+        end
+      end
+
+      def hidden_command
+        @hidden = true
+      end
+
+      def options(&block)
+        @_options = block
+      end
+
+      def subcommand(const, cmd, path = nil)
+        autoload(const, path) if path
+        subcommand_registry.add(->() { const_get(const) }, cmd.to_s)
+      end
+
+      def subcommand_registry
+        @subcommand_registry ||= CLI::Kit::CommandRegistry.new(
+          default: nil,
+          contextual_resolver: nil,
+        )
+      end
+
+      def prerequisite_task(*tasks)
+        tasks.each do |task|
+          prerequisite_tasks[task] = ShopifyCli::Tasks::Registry[task]
+        end
+      end
+
+      def prerequisite_tasks
+        @prerequisite_tasks ||= {}
+      end
+
+      def call_help(*cmds)
+        help = Commands::Help.new(@ctx)
+        help.call(cmds, nil)
+      end
+    end
+
+    def initialize(ctx = nil)
+      @ctx = ctx || ShopifyCli::Context.new
+      self.options = Options.new
+    end
+  end
+end