@shopify/cli-kit 3.39.0 → 3.40.0

package/assets/cli-ruby/lib/shopify_cli/theme/theme_admin_api.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "theme_access_api"
+
+module ShopifyCLI
+  module Theme
+    class ThemeAdminAPI
+      API_VERSION = "unstable"
+
+      attr_reader :shop
+
+      def initialize(ctx, shop = nil)
+        @ctx = ctx
+        @shop = shop || get_shop_or_abort
+      end
+
+      def get(path:, **args, &block)
+        rest_request(method: "GET", path: path, **args, &block)
+      end
+
+      def put(path:, **args, &block)
+        rest_request(method: "PUT", path: path, **args, &block)
+      end
+
+      def post(path:, **args, &block)
+        rest_request(method: "POST", path: path, **args, &block)
+      end
+
+      def delete(path:, **args, &block)
+        rest_request(method: "DELETE", path: path, **args, &block)
+      end
+
+      def get_shop_or_abort # rubocop:disable Naming/AccessorMethodName
+        api_client.get_shop_or_abort(@ctx)
+      end
+
+      def rest_request(**args)
+        status, body, response = api_client.rest_request(
+          @ctx,
+          shop: @shop,
+          api_version: API_VERSION,
+          **args.compact
+        )
+        return yield(status, body, response) if block_given?
+
+        [status, body, response]
+      rescue ShopifyCLI::API::APIRequestForbiddenError,
+             ShopifyCLI::API::APIRequestUnauthorizedError => error
+
+        ##
+        # The Admin API returns 403 Forbidden responses on different
+        # scenarios:
+        #
+        # * when a user doesn't have permissions for a request:
+        #   - <APIRequestForbiddenError: 403 {}>
+        #   - <APIRequestForbiddenError: 403 {"errors":"Unauthorized Access"}>
+        #
+        # * when an asset operation cannot be performed:
+        #   - <APIRequestForbiddenError: 403 {"message":"templates/gift_card.liquid could not be deleted"}>
+        #
+        if empty_response?(error)
+          return permission_error
+        elsif unauthorized_response?(error)
+          @ctx.debug("[#{self.class}] (#{error.class}) cause: #{response_body(error)}")
+          raise ShopifyCLI::Abort, @ctx.message("theme.unauthorized_error", @shop)
+        end
+
+        raise error
+      end
+
+      private
+
+      def api_client
+        @api_client ||= Environment.theme_access_password? ? ThemeAccessAPI : ShopifyCLI::AdminAPI
+      end
+
+      def permission_error
+        ensure_user_error = @ctx.message("theme.ensure_user_error", shop)
+        ensure_user_try_this = @ctx.message("theme.ensure_user_try_this")
+
+        @ctx.abort(ensure_user_error, ensure_user_try_this)
+      end
+
+      def empty_response?(error)
+        response_body(error).empty?
+      end
+
+      def unauthorized_response?(error)
+        parsed_body = JSON.parse(response_body(error))
+        errors = parsed_body["errors"].to_s
+        errors.match?(/Unauthorized Access/)
+      rescue JSON::ParserError
+        false
+      end
+
+      def response_body(error)
+        error&.response&.body.to_s
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/thread_pool/job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  class ThreadPool
+    class Job
+      attr_reader :error, :interval
+
+      def initialize(interval = 0)
+        @interval = interval
+      end
+
+      def perform!
+        raise "`#{self.class.name}#perform!' must be defined"
+      end
+
+      def call
+        perform!
+      rescue StandardError => error
+        @error = error
+      end
+
+      def success?
+        !@error
+      end
+
+      def error?
+        !!@error
+      end
+
+      def recurring?
+        !interval.zero?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  class ThreadPool
+    attr_reader :errors
+
+    def initialize(pool_size: 10)
+      @jobs = Queue.new
+      @pool = Array.new(pool_size) { spawn_thread }
+    end
+
+    def schedule(job)
+      @jobs << job
+    end
+
+    def shutdown
+      @pool.size.times do
+        schedule(-> { throw(:stop_thread) })
+      end
+      @pool.map(&:join)
+    ensure
+      @jobs.close
+    end
+
+    private
+
+    def spawn_thread
+      Thread.new do
+        catch(:stop_thread) do
+          loop { perform(@jobs.pop) }
+        end
+      end
+    end
+
+    def perform(job)
+      job.call
+      reschedule(job) if job.recurring?
+    end
+
+    def reschedule(job)
+      wait(job.interval)
+      schedule(job)
+    end
+
+    def wait(seconds)
+      sleep(seconds)
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+
+module ShopifyCLI
+  ##
+  # `TransformDataStructure` helps to standardize data structure access. It
+  # traverses nested data structures and can convert
+  #
+  # * all strings used as keys to symbols,
+  # * all strings used as keys from `CamelCase` to `snake_case` and
+  # * associative array containers, e.g. from Hash to OpenStruct.
+  #
+  # Standardizing how a data structure is accessed greatly reduces the risk
+  # of subtle bugs especially when dealing with API responses.
+  #
+  #    TransformDataStructure.new(
+  #      symbolize_keys: true,
+  #      underscore_keys: true,
+  #      associative_array_container: OpenStruct
+  #    ).call([{"SomeKey" => "value"}]).tap do |result|
+  #      result.value # => [#<OpenStruct: some_key: "value">]
+  #    end
+  #
+  # Since `TransformDataStructure` is a method object, it can easily be chained:
+  #
+  #    require 'open-uri'
+  #    ShopifyCLI::Result
+  #      .call { open("https://jsonplaceholder.typicode.com/todos/1") }
+  #      .map(&TransformDataStructure.new(symbolize_keys: true, underscore_keys: true))
+  #      .value # => { id: 1, user_id: 1, ... }
+  #
+  class TransformDataStructure
+    include ShopifyCLI::MethodObject
+
+    class << self
+      private
+
+      def valid_associative_array_container(klass)
+        klass.respond_to?(:new) && klass.method_defined?(:[]=)
+      end
+    end
+
+    property! :underscore_keys, accepts: [true, false], default: false, reader: :underscore_keys?
+    property! :symbolize_keys, accepts: [true, false], default: false, reader: :symbolize_keys?
+    property! :shallow, accepts: [true, false], default: false, reader: :shallow?
+    property! :associative_array_container,
+      accepts: ->(c) { c.respond_to?(:new) && c.method_defined?(:[]=) },
+      default: -> { Hash }
+
+    def call(object)
+      case object
+      when Array
+        shallow? ? object.dup : object.map(&self).map(&:value)
+      when Hash
+        object.each.with_object(associative_array_container.new) do |(key, value), result|
+          result[transform_key(key)] = shallow? ? value : call(value).value
+        end
+      else
+        ShopifyCLI::Result.success(object)
+      end
+    end
+
+    private
+
+    def transform_key(key)
+      key
+        .yield_self(&method(:underscore_key))
+        .yield_self(&method(:symbolize_key))
+    end
+
+    def underscore_key(key)
+      return key unless underscore_keys? && key.respond_to?(:to_str)
+
+      key.to_str.dup.tap do |k|
+        k.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        k.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        k.tr!("-", "_")
+        k.gsub!(/\s/, "_")
+        k.gsub!(/__+/, "_")
+        k.downcase!
+      end
+    end
+
+    def symbolize_key(key)
+      return key unless symbolize_keys? && key.respond_to?(:to_sym)
+      key.to_sym
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+require "json"
+require "fileutils"
+require "shopify_cli"
+require "forwardable"
+require "uri"
+
+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, :authenticated?, :stats, :urls, :running_on?
+
+    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",
+      mac_m1: "https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-darwin-arm64.zip",
+      linux: "https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip",
+      windows: "https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-windows-amd64.zip",
+    }
+
+    NGROK_TUNNELS_URI = URI.parse("http://localhost:4040/api/tunnels")
+    TUNNELS_FIELD = "tunnels"
+    TUNNEL_ADDRESS_KEY_PATH = ["config", "addr"]
+    PUBLIC_URL_FIELD = "public_url"
+
+    ##
+    # 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)
+      ctx.abort(ctx.message("core.tunnel.error.signup_required", ShopifyCLI::TOOL_NAME)) unless authenticated?
+      url, account = start_ngrok(ctx, port)
+      ctx.puts(ctx.message("core.tunnel.start_with_account", url, account))
+      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(ngrok_path(ctx), "authtoken", token)
+    end
+
+    ##
+    # returns a boolean: if the user has a ngrok token to authenticate
+    #
+    def authenticated?
+      ngrok_config_path = File.join(Dir.home, ".ngrok2/ngrok.yml")
+      return false unless File.exist?(ngrok_config_path)
+      File.read(ngrok_config_path).include?("authtoken")
+    end
+
+    ##
+    # will return the statistics of the current running tunnels
+    #
+    # #### Returns
+    #
+    # * `stats` - the hash of running statistics returning from the ngrok api
+    #
+    def stats
+      response = Net::HTTP.get_response(NGROK_TUNNELS_URI)
+      JSON.parse(response.body)
+    rescue
+      {}
+    end
+
+    ##
+    # will return the urls of the current running tunnels
+    #
+    # #### Returns
+    #
+    # * `stats` - the array of urls
+    #
+    def urls
+      tunnels = stats.dig(TUNNELS_FIELD)
+      tunnels.map { |tunnel| tunnel.dig(PUBLIC_URL_FIELD) }
+    rescue
+      []
+    end
+
+    ##
+    # Returns Boolean if a tunnel is running on a given port
+    #
+    # #### Parameters
+    #
+    # * `port` - port to check
+    #
+    # #### Returns
+    #
+    # * true / false
+    #
+    def running_on?(port)
+      extract_port = ->(tunnel) { URI(tunnel.dig(*TUNNEL_ADDRESS_KEY_PATH)).port }
+      matches_port = ->(occupied_port) { occupied_port == port }
+      stats.fetch(TUNNELS_FIELD, []).map(&extract_port).any?(&matches_port)
+    rescue
+      false
+    end
+
+    private
+
+    def install(ctx)
+      ngrok = "ngrok#{ctx.executable_file_extension}"
+      return if File.exist?(ngrok_path(ctx))
+      check_prereq_command(ctx, "curl")
+      check_prereq_command(ctx, ctx.linux? ? "unzip" : "tar")
+      spinner = CLI::UI::SpinGroup.new
+      spinner.add(ctx.message("core.tunnel.installing")) 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
+        args = if ctx.linux?
+          %W(unzip -u #{zip_dest})
+        else
+          %W(tar -xf #{zip_dest})
+        end
+        ctx.system(*args, chdir: ShopifyCLI.cache_dir)
+        ctx.rm(zip_dest)
+      end
+      spinner.wait
+
+      # final check to see if ngrok is accessible
+      unless File.exist?(ngrok_path(ctx))
+        ctx.abort(ctx.message("core.tunnel.error.ngrok", ngrok, ShopifyCLI.cache_dir))
+      end
+    end
+
+    def fetch_url(ctx, log_path)
+      LogParser.new(log_path)
+    rescue NgrokError => e
+      # Full error messages/descriptions: https://ngrok.com/docs/errors
+      case e.message
+      when /ERR_NGROK_107/
+        ctx.abort(ctx.message("tunnel.invalid_token", e.message))
+      when /ERR_NGROK_108/
+        ctx.abort(ctx.message("tunnel.duplicate_session", e.message))
+      end
+      raise e.class, e.message
+    rescue RuntimeError => e
+      stop(ctx)
+      raise e.class, e.message
+    end
+
+    def ngrok_path(ctx)
+      ngrok = "ngrok#{ctx.executable_file_extension}"
+      File.join(ShopifyCLI.cache_dir, ngrok)
+    end
+
+    def seconds_to_hm(seconds)
+      format("%d hours %d minutes", seconds / 3600, seconds / 60 % 60)
+    end
+
+    def start_ngrok(ctx, port)
+      ngrok_command = "\"#{ngrok_path(ctx)}\" http -inspect=false -log=stdout -log-level=debug #{port}"
+      process = ShopifyCLI::ProcessSupervision.start(:ngrok, ngrok_command)
+      log = fetch_url(ctx, process.log_path)
+      [log.url, log.account]
+    end
+
+    def check_prereq_command(ctx, command)
+      cmd_path = ctx.which(command)
+      ctx.abort(ctx.message("core.tunnel.error.prereq_command_required", command)) if cmd_path.nil?
+      ctx.done(ctx.message("core.tunnel.prereq_command_location", command, cmd_path))
+    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:(.*)\s+SessionDuration/)&.captures
+        @account = account&.empty? ? nil : account
+      end
+
+      def error
+        @log.scan(/msg="command failed" err="([^"]+)"/).flatten
+      end
+    end
+
+    private_constant :LogParser
+  end
+end

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

@@ -0,0 +1,21 @@
+module ShopifyCLI
+  module Utilities
+    def self.version_dropping_pre_and_build(version)
+      Semantic::Version.new("#{version.major}.#{version.minor}.#{version.patch}")
+    end
+
+    def self.directory(pattern, curr)
+      loop do
+        return nil if curr == "/" || /^[A-Z]:\/$/.match?(curr)
+        file = File.join(curr, pattern)
+        return curr if File.exist?(file)
+        curr = File.dirname(curr)
+      end
+    end
+
+    def self.deep_merge(first, second)
+      merger = proc { |_key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+      first.merge(second, &merger)
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module ShopifyCLI
+  VERSION = "2.34.0"
+end