@shopify/cli-kit 3.39.0 → 3.40.1

package/assets/cli-ruby/lib/shopify_cli/method_object.rb

@@ -0,0 +1,123 @@
+module ShopifyCLI
+  ##
+  # The `MethodObject` mixin can be included in any class that implements `call`
+  # to ensure that
+  #
+  # * `call` will always return a `ShopifyCLI::Result` by prepending a module
+  #   that takes care of the result wrapping and
+  # * a `to_proc` method that allows instances of this class to be passed as a
+  #   block.
+  #
+  # For convenience, this mixin also adds the corresponding class methods:
+  # `call` and `to_proc`. Method and result objects pair nicely as they greatly
+  # simplify the creation of complex processing chains:
+  #
+  #   class Serialize
+  #     include MethodObject
+  #
+  #     def call(attrs)
+  #       attrs.to_json
+  #     end
+  #   end
+  #
+  #   class Deserialize
+  #     include MethodObject
+  #
+  #     def call(json)
+  #       JSON.parse(json)
+  #     end
+  #   end
+  #
+  #   Serialize
+  #     .call(firstname: "John", lastname: "Doe")
+  #     .then(&Deserialize)
+  #     .map { |attrs| OpenStruct.new(attrs) }
+  #     .unwrap(nil)
+  #
+  # While this example is contrived, it still illustrates some key advantages of
+  # this programming paradigm:
+  #
+  # * chaining operations is as simple as repeatedly calling `then` or `map`,
+  # * method objects don't have to be manually instantiated but can be
+  #   constructed using the `&` operator,
+  # * error handling is deferred until the result is unwrapped.
+  #
+  # Please see the section for `ShopifyCLI::Result`,
+  # `ShopifyCLI::Result::Success`, and `ShopifyCLI::Result::Failure` for more
+  # information on the API of result objects.
+  #
+  module MethodObject
+    module AutoCreateResultObject
+      def self.ruby2_keywords(*); end unless respond_to?(:ruby2_keywords, true)
+
+      ##
+      # invokes the original `call` implementation and wraps its return value
+      # into a result object.
+      #
+      ruby2_keywords def call(*args, &block)
+        Result.wrap { super(*args, &block) }.call
+      end
+    end
+
+    module ClassMethods
+      ##
+      # creates a new instance and invokes `call`. Any positional argument
+      # is forward to `call`. Keyword arguments are either forwarded to the
+      # initializer or to `call`. If the keyword argument matches the name of
+      # property, it is forwarded to the initializer, otherwise to call.
+      #
+      ruby2_keywords def call(*args, &block)
+        # This is an extremely complicated case of delegation. The method wants
+        # to delegate arguments, but to have control over which keyword
+        # arguments are delegated. I'm not sure the forward and backward
+        # compatibility of this unusual form of delegation has really been
+        # explored or there's any good way to support it. So I have done
+        # done something hacky here and I'm looking at the last argument and
+        # modifying the package of arguments to be delegated in-place.
+        if args.last.is_a?(Hash)
+          kwargs = args.last
+
+          initializer_kwargs = kwargs.slice(*properties.keys)
+          instance = new(**initializer_kwargs)
+
+          kwargs.reject! { |key| initializer_kwargs.key?(key) }
+          args.pop if kwargs.empty?
+          instance.call(*args, &block)
+        else
+          # Since the former is so complicated - let's have a fast path that
+          # is much simpler.
+          new.call(*args, &block)
+        end
+      end
+
+      ##
+      # returns a proc that invokes `call` with all arguments it receives when
+      # called itself.
+      #
+      def to_proc
+        method(:call).to_proc
+      end
+    end
+
+    ##
+    # is invoked when this mixin is included into a class. This results in
+    #
+    # * including `SmartProperties`,
+    # * prepending the result wrapping mechanism, and
+    # * adding the class methods `.call` and `.to_proc`.
+    #
+    def self.included(method_object_implementation)
+      method_object_implementation.prepend(AutoCreateResultObject)
+      method_object_implementation.include(SmartProperties)
+      method_object_implementation.extend(ClassMethods)
+    end
+
+    ##
+    # returns a proc that invokes `call` with all arguments it receives when
+    # called itself.
+    #
+    def to_proc
+      method(:call).to_proc
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/migrator/migration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require "date"
+
+module ShopifyCLI
+  module Migrator
+    class Migration
+      attr_reader :name, :path, :date
+
+      def initialize(name:, path:, date:)
+        @name = name
+        @path = path
+        @date = date
+      end
+
+      def run
+        require(path)
+        ShopifyCLI::Migrator::Migrations.const_get(class_name).run
+      rescue StandardError
+        # Continue
+      end
+
+      def class_name
+        name.split("_").collect(&:capitalize).join
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/migrator/migrations/1631709766_noop.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Migrator
+    module Migrations
+      class Noop
+        def self.run
+          # This is a noop migration to be used as a reference
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/migrator/migrations/1633691650_merge_reporting_configuration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Migrator
+    module Migrations
+      # Before this migration, users configured automatic usage and error
+      # reporting independenty. We changed it to be a single configuration
+      # in the environment's configuration and therefore we need a migration
+      # to merge the configurations.
+      class MergeReportingConfiguration
+        def self.run
+          analytics_enabled = ShopifyCLI::Config.get_bool(
+            Constants::Config::Sections::Analytics::NAME,
+            Constants::Config::Sections::Analytics::Fields::ENABLED,
+            default: false
+          )
+          error_reporting_enabled = ShopifyCLI::Config.get_bool(
+            "error-tracking",
+            "automatic-reporting",
+            default: false
+          )
+          # Because we are merging configuration options, both need
+          # to be true to for the new flag to be true. Otherwise,
+          # we delete them and let the CLI prompt the user again.
+          should_merge_be_true = analytics_enabled && error_reporting_enabled
+
+          unless should_merge_be_true
+            ShopifyCLI::Config.unset(
+              Constants::Config::Sections::Analytics::NAME,
+              Constants::Config::Sections::Analytics::Fields::ENABLED
+            )
+            ShopifyCLI::Config.unset(
+              "error-tracking",
+              "automatic-reporting"
+            )
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/migrator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "date"
+
+module ShopifyCLI
+  module Migrator
+    autoload :Migration, "shopify_cli/migrator/migration"
+
+    def self.migrate(
+      migrations_directory: File.expand_path("migrator/migrations", __dir__)
+    )
+      baseline_date = last_migration_date
+      unless baseline_date.nil?
+        migrations(migrations_directory: migrations_directory)
+          .select do |m|
+            m.date > baseline_date.to_i
+          end
+          .each(&:run)
+      end
+
+      store_last_migration_date
+    end
+
+    def self.store_last_migration_date
+      ShopifyCLI::DB.set(ShopifyCLI::Constants::StoreKeys::LAST_MIGRATION_DATE => Time.now.to_i)
+    end
+
+    def self.last_migration_date
+      ShopifyCLI::DB.get(ShopifyCLI::Constants::StoreKeys::LAST_MIGRATION_DATE)
+    end
+
+    def self.migrations(migrations_directory:)
+      Dir.glob(File.join(migrations_directory, "*.rb")).map do |file_path|
+        file_name = File.basename(file_path).gsub(".rb", "")
+        file_name_components = file_name.split("_")
+        date_timestamp = file_name_components[0].to_i
+        migration_name = file_name_components.drop(1).join("_")
+
+        Migrator::Migration.new(
+          name: migration_name,
+          date: Time.at(date_timestamp).to_i,
+          path: file_path
+        )
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/options.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require "shopify_cli"
+require "optparse"
+
+module ShopifyCLI
+  class Options
+    include SmartProperties
+
+    attr_reader :flags, :subcommand, :help
+
+    def initialize
+      @flags = {}
+      @help = false
+    end
+
+    def parse(options_block, args)
+      @args = args
+      if options_block.respond_to?(:call) && args
+        parse_flags(options_block)
+      else
+        parser.permute!(@args)
+      end
+      @args
+    end
+
+    def parse_flags(block)
+      block.call(parser, @flags)
+      parser.permute!(@args)
+    end
+
+    def parser
+      @parser ||= begin
+        opt = OptionParser.new
+        opt.on("--help", "-h", Context.message("core.options.help_text")) do |v|
+          @help = v
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/packager.rb

@@ -0,0 +1,108 @@
+module ShopifyCLI
+  class Packager
+    PACKAGING_DIR = File.join(ShopifyCLI::ROOT, "packaging")
+    BUILDS_DIR = File.join(PACKAGING_DIR, "builds", ShopifyCLI::VERSION)
+
+    def initialize
+      FileUtils.mkdir_p(BUILDS_DIR)
+    end
+
+    def build_debian
+      ensure_program_installed("dpkg-deb", "brew install dpkg")
+
+      root_dir = File.join(PACKAGING_DIR, "debian")
+      debian_dir = File.join(root_dir, "shopify-cli", "DEBIAN")
+      FileUtils.mkdir_p(debian_dir)
+
+      puts "\nBuilding Debian package"
+
+      puts "Generating metadata files…"
+      Dir.glob("#{debian_dir}/*").each { |file| File.delete(file) }
+
+      metadata_files = %w(control preinst prerm)
+      metadata_files.each do |file|
+        file_path = File.join(debian_dir, file)
+
+        file_contents = File.read(File.join(root_dir, "#{file}.base"))
+        file_contents = file_contents.gsub("SHOPIFY_CLI_VERSION", ShopifyCLI::VERSION)
+        File.open(file_path, "w", 0775) { |f| f.write(file_contents) }
+      end
+
+      puts "Building package…"
+      Dir.chdir(root_dir)
+      raise "Failed to build package" unless system("dpkg-deb", "-b", "shopify-cli")
+
+      output_path = File.join(root_dir, "shopify-cli.deb")
+      final_path = File.join(BUILDS_DIR, "shopify-cli-#{ShopifyCLI::VERSION}.deb")
+
+      puts "Moving generated package: \n  From: #{output_path}\n  To: #{final_path}\n\n"
+      FileUtils.mv(output_path, final_path)
+    end
+
+    def build_rpm
+      ensure_program_installed("rpmbuild", "brew install rpm")
+
+      root_dir = File.join(PACKAGING_DIR, "rpm")
+      rpm_build_dir = File.join(root_dir, "build")
+      FileUtils.mkdir_p(rpm_build_dir)
+
+      spec_path = File.join(root_dir, "shopify-cli.spec")
+      puts "\nBuilding RPM package"
+
+      puts "Generating spec file…"
+      File.delete(spec_path) if File.exist?(spec_path)
+
+      spec_contents = File.read(File.join(root_dir, "shopify-cli.spec.base"))
+      spec_contents = spec_contents.gsub("SHOPIFY_CLI_VERSION", ShopifyCLI::VERSION)
+      File.write(spec_path, spec_contents)
+
+      puts "Building package…"
+      Dir.chdir(root_dir)
+      system("rpmbuild", "-bb", File.basename(spec_path))
+
+      output_dir = File.join(root_dir, "build", "noarch")
+
+      puts "Moving generated packages: \n  From: #{output_dir}\n  To: #{BUILDS_DIR}\n\n"
+      FileUtils.mv(Dir.glob("#{output_dir}/*.rpm"), BUILDS_DIR)
+    end
+
+    def build_homebrew
+      root_dir = File.join(PACKAGING_DIR, "homebrew")
+
+      build_path = File.join(BUILDS_DIR, "shopify-cli@2.rb")
+      puts "\nBuilding Homebrew package"
+
+      puts "Generating formula…"
+      File.delete(build_path) if File.exist?(build_path)
+
+      spec_contents = File.read(File.join(root_dir, "shopify-cli@2.base.rb"))
+      spec_contents = spec_contents.gsub("SHOPIFY_CLI_VERSION", ShopifyCLI::VERSION)
+
+      puts "Grabbing sha256 checksum from Rubygems.org"
+      require "digest/sha2"
+      require "open-uri"
+      gem_checksum = URI.open("https://rubygems.org/downloads/shopify-cli-#{ShopifyCLI::VERSION}.gem") do |io|
+        Digest::SHA256.new.hexdigest(io.read)
+      end
+
+      puts "Got sha256 checksum for gem: #{gem_checksum}"
+      spec_contents = spec_contents.gsub("SHOPIFY_CLI_GEM_CHECKSUM", gem_checksum)
+
+      puts "Writing generated formula\n  To: #{build_path}\n\n"
+      File.write(build_path, spec_contents)
+    end
+
+    private
+
+    def ensure_program_installed(program, installation_cmd)
+      unless system(program, "--version", out: File::NULL, err: File::NULL)
+        raise <<~MESSAGE
+
+          Could not find program #{program} which is required to build the package.
+          You can install it by running #{installation_cmd}.
+
+        MESSAGE
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/partners_api/app_extensions/job.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "shopify_cli/thread_pool/job"
+
+module ShopifyCLI
+  class PartnersAPI
+    class AppExtensions
+      class Job < ShopifyCLI::ThreadPool::Job
+        attr_reader :result
+
+        def initialize(ctx, app, type)
+          super()
+          @ctx = ctx
+          @app = app
+          @api_key = @app["apiKey"]
+          @type = type
+        end
+
+        def perform!
+          resp = PartnersAPI.query(@ctx, "get_extension_registrations", **params)
+          @result = resp&.dig("data", "app") || {}
+        end
+
+        def patch_app_with_extensions!
+          @app.merge!(result)
+        end
+
+        private
+
+        def params
+          { api_key: @api_key, type: @type }
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/partners_api/app_extensions.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "shopify_cli/thread_pool"
+
+require_relative "app_extensions/job"
+
+module ShopifyCLI
+  class PartnersAPI
+    class AppExtensions
+      class << self
+        def fetch_apps_extensions(ctx, org, type)
+          jobs = apps(org).map { |app| AppExtensions::Job.new(ctx, app, type) }
+
+          consume_jobs!(jobs)
+          patch_apps_with_extensions!(jobs)
+
+          org
+        end
+
+        private
+
+        def apps(org)
+          (org && org["apps"]) || []
+        end
+
+        def consume_jobs!(jobs)
+          thread_pool = ShopifyCLI::ThreadPool.new(pool_size: 1)
+          jobs.each do |job|
+            thread_pool.schedule(job)
+          end
+          thread_pool.shutdown
+
+          raise_if_any_error(jobs)
+        end
+
+        def patch_apps_with_extensions!(jobs)
+          jobs.each(&:patch_app_with_extensions!)
+        end
+
+        def raise_if_any_error(jobs)
+          jobs.find(&:error?).tap { |job| raise job.error if job }
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/partners_api/organizations.rb

@@ -0,0 +1,45 @@
+module ShopifyCLI
+  class PartnersAPI
+    class Organizations
+      class << self
+        def fetch_all(ctx)
+          resp = PartnersAPI.query(ctx, "all_organizations")
+          (resp&.dig("data", "organizations", "nodes") || []).map do |org|
+            org["stores"] = (org.dig("stores", "nodes") || [])
+            org
+          end
+        end
+
+        def fetch(ctx, id:)
+          resp = PartnersAPI.query(ctx, "find_organization", id: id)
+          org = resp&.dig("data", "organizations", "nodes")&.first
+          return nil if org.nil?
+          org["stores"] = (org.dig("stores", "nodes") || [])
+          org
+        end
+
+        def fetch_all_with_apps(ctx)
+          resp = PartnersAPI.query(ctx, "all_orgs_with_apps")
+          (resp&.dig("data", "organizations", "nodes") || []).map do |org|
+            org["stores"] = (org.dig("stores", "nodes") || [])
+            org["apps"] = (org.dig("apps", "nodes") || [])
+            org
+          end
+        end
+
+        def fetch_with_apps(ctx, id:)
+          resp = PartnersAPI.query(ctx, "find_organization_with_apps", id: id)
+          organization = resp&.dig("data", "organizations", "nodes")&.first
+          return unless organization
+
+          organization.tap { organization["apps"] = (organization.dig("apps", "nodes") || []) }
+        end
+
+        def fetch_with_extensions(ctx, type, id:)
+          organization = fetch_with_apps(ctx, id: id)
+          AppExtensions.fetch_apps_extensions(ctx, organization, type)
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/partners_api.rb

@@ -0,0 +1,91 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  ##
+  # ShopifyCLI::PartnersAPI provides easy access to the partners dashboard CLI
+  # schema.
+  #
+  class PartnersAPI < API
+    autoload :Organizations, "shopify_cli/partners_api/organizations"
+    autoload :AppExtensions, "shopify_cli/partners_api/app_extensions"
+
+    class << self
+      ##
+      # issues a graphql query or mutation to the Shopify Partners Dashboard CLI Schema.
+      # It loads a graphql query from a file so that you do not need to use large
+      # unwieldy query strings. It also handles authentication for you as well.
+      #
+      # #### Parameters
+      # - `ctx`: running context from your command
+      # - `query_name`: name of the query you want to use, loaded from the `lib/graphql` directory.
+      # - `**variables`: a hash of variables to be supplied to the query or 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::PartnersAPI.query(@ctx, 'all_organizations')
+      #
+      def query(ctx, query_name, **variables)
+        CLI::Kit::Util.begin do
+          api_client(ctx).query(query_name, variables: variables)
+        end.retry_after(
+          API::APIRequestUnauthorizedError,
+          retries: 1,
+          only: -> { !IdentityAuth::EnvAuthToken.partners_token_present? }
+        ) do
+          ShopifyCLI::IdentityAuth.new(ctx: ctx).reauthenticate
+        end
+      rescue API::APIRequestUnauthorizedError => e
+        if (request_info = auth_failure_info(ctx, e))
+          ctx.puts(ctx.message("core.api.error.failed_auth_debugging", request_info))
+        end
+        ctx.abort(ctx.message("core.api.error.failed_auth"))
+      rescue API::APIRequestNotFoundError
+        ctx.puts(ctx.message("core.partners_api.error.account_not_found", ShopifyCLI::TOOL_NAME))
+      end
+
+      def partners_url_for(organization_id, api_client_id)
+        if ShopifyCLI::Shopifolk.acting_as_shopify_organization?
+          organization_id = "internal"
+        end
+        "https://#{Environment.partners_domain}/#{organization_id}/apps/#{api_client_id}"
+      end
+
+      private
+
+      def api_client(ctx)
+        identity_auth = ShopifyCLI::IdentityAuth.new(ctx: ctx)
+        new(
+          ctx: ctx,
+          token: identity_auth.fetch_or_auth_partners_token,
+          url: "https://#{Environment.partners_domain}/api/cli/graphql",
+        )
+      end
+
+      def auth_failure_info(ctx, error)
+        if error.response
+          headers = %w(www-authenticate x-request-id)
+          request_info = headers.map { |h| "#{h}: #{error.response[h]}" if error.response.key?(h) }.join("\n")
+          ctx.debug("Full headers: #{error.response.each_header.to_h}")
+          request_info
+        end
+      rescue => e
+        ctx.debug("Couldn't fetch auth failure information from #{error}: #{e}")
+      end
+    end
+
+    def auth_headers(token)
+      { Authorization: "Bearer #{token}" }
+    end
+  end
+end