@shopify/cli-kit 3.69.4 → 3.70.0

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

@@ -1,123 +0,0 @@
-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

@@ -1,27 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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/partners_api/app_extensions/job.rb

@@ -1,36 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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