shopify-cli 1.12.0 → 2.0.1

data/lib/project_types/theme/forms/create.rb

@@ -1,22 +0,0 @@
-module Theme
-  module Forms
-    class Create < ShopifyCli::Form
-      attr_accessor :name
-      flag_arguments :title, :password, :store, :env
-
-      def ask
-        self.store ||= CLI::UI::Prompt.ask(ctx.message("theme.forms.ask_store"), allow_empty: false)
-        ctx.puts(ctx.message("theme.forms.create.private_app", store))
-        self.password ||= CLI::UI::Prompt.ask(ctx.message("theme.forms.ask_password"), allow_empty: false)
-        self.title ||= CLI::UI::Prompt.ask(ctx.message("theme.forms.create.ask_title"), allow_empty: false)
-        self.name = self.title.downcase.split(" ").join("_")
-
-        errors = []
-        errors << "store" if store.strip.empty?
-        errors << "password" if password.strip.empty?
-        errors << "title" if title.strip.empty?
-        ctx.abort(ctx.message("theme.forms.errors", errors.join(", ").capitalize)) unless errors.empty?
-      end
-    end
-  end
-end

data/lib/project_types/theme/tasks/ensure_themekit_installed.rb

@@ -1,78 +0,0 @@
-module Theme
-  module Tasks
-    class EnsureThemekitInstalled < ShopifyCli::Task
-      URL = "https://shopify-themekit.s3.amazonaws.com/releases/latest.json"
-      OSMAP = {
-        mac: "darwin-amd64",
-        linux: "linux-amd64",
-        windows: "windows-amd64",
-      }
-      VERSION_CHECK_INTERVAL = 604800
-      VERSION_CHECK_SECTION = "themekit_version_check"
-      LAST_CHECKED_AT_FIELD = "last_checked_at"
-
-      def call(ctx)
-        _out, stat = ctx.capture2e(Themekit::THEMEKIT)
-        unless stat.success?
-          CLI::UI::Frame.open(ctx.message("theme.tasks.ensure_themekit_installed.installing_themekit")) do
-            install_themekit(ctx)
-          end
-        end
-
-        now = Time.now.to_i
-        if ShopifyCli::Feature.enabled?(:themekit_auto_update) && (time_of_last_check + VERSION_CHECK_INTERVAL) < now
-          CLI::UI::Frame.open(ctx.message("theme.tasks.ensure_themekit_installed.updating_themekit")) do
-            unless Themekit.update(ctx)
-              ctx.abort(ctx.message("theme.tasks.ensure_themekit_installed.errors.update_fail"))
-            end
-            update_time_of_last_check(now)
-          end
-        end
-      end
-
-      private
-
-      def install_themekit(ctx)
-        require "json"
-        require "fileutils"
-        require "digest"
-        require "open-uri"
-
-        begin
-          begin
-            releases = JSON.parse(Net::HTTP.get(URI(URL)))
-            release = releases["platforms"].find { |r| r["name"] == OSMAP[ctx.os] }
-          rescue
-            ctx.abort(ctx.message("theme.tasks.ensure_themekit_installed.errors.releases_fail"))
-          end
-
-          ctx.puts(ctx.message("theme.tasks.ensure_themekit_installed.downloading", releases["version"]))
-          _out, stat = ctx.capture2e("curl", "-o", Themekit::THEMEKIT, release["url"])
-          ctx.abort(ctx.message("theme.tasks.ensure_themekit_installed.errors.write_fail")) unless stat.success?
-
-          ctx.puts(ctx.message("theme.tasks.ensure_themekit_installed.verifying"))
-          if Digest::MD5.file(Themekit::THEMEKIT) == release["digest"]
-            FileUtils.chmod("+x", Themekit::THEMEKIT)
-            ctx.puts(ctx.message("theme.tasks.ensure_themekit_installed.successful"))
-
-            auto = CLI::UI.confirm(ctx.message("theme.tasks.ensure_themekit_installed.auto_update"))
-            ShopifyCli::Feature.set(:themekit_auto_update, auto)
-          else
-            ctx.abort(ctx.message("theme.tasks.ensure_themekit_installed.errors.digest_fail"))
-          end
-        rescue StandardError, ShopifyCli::Abort => e
-          FileUtils.rm(Themekit::THEMEKIT) if File.exist?(Themekit::THEMEKIT)
-          raise e
-        end
-      end
-
-      def time_of_last_check
-        (val = ShopifyCli::Config.get(VERSION_CHECK_SECTION, LAST_CHECKED_AT_FIELD)) ? val.to_i : 0
-      end
-
-      def update_time_of_last_check(time)
-        ShopifyCli::Config.set(VERSION_CHECK_SECTION, LAST_CHECKED_AT_FIELD, time)
-      end
-    end
-  end
-end

data/lib/project_types/theme/themekit.rb

@@ -1,113 +0,0 @@
-module Theme
-  class Themekit
-    THEMEKIT = File.join(ShopifyCli.cache_dir, "themekit")
-
-    class << self
-      def add_flags(flags)
-        flags.map do |key, value|
-          flag = "--#{key}"
-          flag += "=#{value}" if value.is_a?(String)
-          flag
-        end
-      end
-
-      def connect(ctx, store:, password:, themeid:, env:)
-        command = build_command("get", env)
-        command << "--password=#{password}"
-        command << "--store=#{store}"
-        command << "--themeid=#{themeid}"
-
-        stat = ctx.system(*command)
-        stat.success?
-      end
-
-      def create(ctx, password:, store:, name:, env:)
-        command = build_command("new", env)
-        command << "--password=#{password}"
-        command << "--store=#{store}"
-        command << "--name=#{name}"
-
-        stat = ctx.system(*command)
-        stat.success?
-      end
-
-      def deploy(ctx, flags: nil, env:)
-        unless push(ctx, flags: flags, env: env)
-          ctx.abort(ctx.message("theme.deploy.push_fail"))
-        end
-        ctx.done(ctx.message("theme.deploy.info.pushed"))
-
-        command = build_command("publish", env)
-        (command << flags).compact!
-        command.flatten!
-
-        stat = ctx.system(*command)
-        stat.success?
-      end
-
-      def generate_env(ctx, store:, password:, themeid:, env:)
-        command = build_command("configure", env)
-        command << "--password=#{password}"
-        command << "--store=#{store}"
-        command << "--themeid=#{themeid}"
-
-        stat = ctx.system(*command)
-        stat.success?
-      end
-
-      def push(ctx, files: nil, flags: nil, remove: false, env:)
-        action = remove ? "remove" : "deploy"
-        command = build_command(action, env)
-
-        (command << files << flags).compact!
-        command.flatten!
-
-        stat = ctx.system(*command)
-        stat.success?
-      end
-
-      def query_themes(ctx, store:, password:)
-        begin
-          resp = ::ShopifyCli::AdminAPI.rest_request(
-            ctx,
-            shop: store,
-            token: password,
-            path: "themes.json",
-          )
-        rescue ShopifyCli::API::APIRequestUnauthorizedError
-          ctx.abort(ctx.message("theme.themekit.query_themes.bad_password"))
-        rescue StandardError
-          ctx.abort(ctx.message("theme.themekit.query_themes.not_connect"))
-        end
-
-        resp[1]["themes"].map { |theme| [theme["name"], theme["id"]] }.to_h
-      end
-
-      def serve(ctx, flags: nil, env:)
-        command = build_command("open", env)
-        out, stat = ctx.capture2e(*command)
-        ctx.puts(out)
-        ctx.abort(ctx.message("theme.serve.open_fail")) unless stat.success?
-
-        command = build_command("watch", env)
-        (command << flags).compact!
-        command.flatten!
-        ctx.system(*command)
-      end
-
-      def update(ctx)
-        command = build_command("update")
-        ctx.system(*command)
-      end
-
-      private
-
-      def build_command(action, env = nil)
-        command = [THEMEKIT, action]
-        command << "--no-update-notifier"
-        command << "--env=#{env}" if env
-        command
-      end
-    end
-  end
-end

data/lib/shopify-cli/commands/connect.rb

@@ -1,64 +0,0 @@
-require "shopify_cli"
-
-module ShopifyCli
-  module Commands
-    class Connect < ShopifyCli::Command
-      class << self
-        def call(args, command_name)
-          ProjectType.load_type(args[0]) unless args.empty?
-          super
-        end
-
-        def help
-          ShopifyCli::Context.message("core.connect.help", ShopifyCli::TOOL_NAME)
-        end
-      end
-
-      def call(args, command_name)
-        if Project.current&.env
-          @ctx.puts(@ctx.message("core.connect.already_connected_warning"))
-        end
-
-        project_type = ask_project_type
-
-        klass = ProjectType.load_type(project_type)&.connect_command
-
-        if klass
-          klass.ctx = @ctx
-          klass.call(args, command_name, "connect")
-        else
-          app = default_connect(project_type)
-          @ctx.done(@ctx.message("core.connect.connected", app))
-        end
-      end
-
-      def ask_project_type
-        CLI::UI::Prompt.ask(@ctx.message("core.connect.project_type_select")) do |handler|
-          ShopifyCli::Commands::Create.all_visible_type.each do |type|
-            handler.option(type.project_name) { type.project_type }
-          end
-        end
-      end
-
-      def default_connect(project_type)
-        org = ShopifyCli::Tasks::EnsureEnv.call(@ctx, regenerate: true)
-        write_cli_yml(project_type, org["id"]) unless Project.has_current?
-        api_key = Project.current(force_reload: true).env["api_key"]
-        get_app(org["apps"], api_key).first["title"]
-      end
-
-      def write_cli_yml(project_type, org_id)
-        ShopifyCli::Project.write(
-          @ctx,
-          project_type: project_type,
-          organization_id: org_id,
-        )
-        @ctx.done(@ctx.message("core.connect.cli_yml_saved"))
-      end
-
-      def get_app(apps, api_key)
-        apps.select { |app| app["apiKey"] == api_key }
-      end
-    end
-  end
-end

data/lib/shopify-cli/commands/create.rb

@@ -1,50 +0,0 @@
-require "shopify_cli"
-
-module ShopifyCli
-  module Commands
-    class Create < ShopifyCli::Command
-      def self.call(args, command_name)
-        ProjectType.load_type(args[0]) unless args.empty?
-        super
-      end
-
-      def call(args, command_name)
-        unless args.empty?
-          @ctx.puts(@ctx.message("core.create.error.invalid_app_type", args[0]))
-          return @ctx.puts(self.class.help)
-        end
-
-        type_name = CLI::UI::Prompt.ask(@ctx.message("core.create.project_type_select")) do |handler|
-          self.class.all_visible_type.each do |type|
-            handler.option(type.project_name) { type.project_type }
-          end
-        end
-
-        klass = ProjectType.load_type(type_name).create_command
-        klass.ctx = @ctx
-        klass.call(args, command_name, "create")
-      end
-
-      def self.all_visible_type
-        ProjectType
-          .load_all
-          .select { |type| !type.hidden? }
-      end
-
-      def self.help
-        project_types = all_visible_type.map(&:project_type).sort.join(" | ")
-        ShopifyCli::Context.message("core.create.help", ShopifyCli::TOOL_NAME, project_types)
-      end
-
-      def self.extended_help
-        <<~HELP
-          #{
-            all_visible_type.map do |type|
-              type.create_command.help
-            end.join("\n")
-          }
-        HELP
-      end
-    end
-  end
-end

data/lib/shopify-cli/oauth.rb

@@ -1,198 +0,0 @@
-require "base64"
-require "digest"
-require "json"
-require "net/http"
-require "securerandom"
-require "openssl"
-require "shopify_cli"
-require "uri"
-require "webrick"
-
-module ShopifyCli
-  class OAuth
-    include SmartProperties
-
-    autoload :Servlet, "shopify-cli/oauth/servlet"
-
-    class Error < StandardError; end
-    LocalRequest = Struct.new(:method, :path, :query, :protocol)
-
-    DEFAULT_PORT = 3456
-    REDIRECT_HOST = "http://127.0.0.1:#{DEFAULT_PORT}"
-
-    property! :ctx
-    property! :service, accepts: String
-    property! :client_id, accepts: String
-    property! :scopes
-    property :store, default: -> { ShopifyCli::DB.new }
-    property :secret, accepts: String
-    property :request_exchange, accepts: String
-    property :options, default: -> { {} }, accepts: Hash
-    property :auth_path, default: "/authorize", accepts: ->(path) { path.is_a?(String) && path.start_with?("/") }
-    property :token_path, default: "/token", accepts: ->(path) { path.is_a?(String) && path.start_with?("/") }
-    property :state_token, accepts: String, default: SecureRandom.hex(30)
-    property :code_verifier, accepts: String, default: SecureRandom.hex(30)
-
-    attr_accessor :response_query
-
-    def authenticate(url)
-      return if refresh_exchange_token(url)
-      return if refresh_access_token(url)
-      initiate_authentication(url)
-      request_access_token(url, code: receive_access_code)
-      request_exchange_token(url) if should_exchange
-    end
-
-    def code_challenge
-      @code_challenge ||= Base64.urlsafe_encode64(
-        OpenSSL::Digest::SHA256.digest(code_verifier),
-        padding: false,
-      )
-    end
-
-    def server
-      @server ||= begin
-        server = WEBrick::HTTPServer.new(
-          Port: DEFAULT_PORT,
-          Logger: WEBrick::Log.new(File.open(File::NULL, "w")),
-          AccessLog: [],
-        )
-        server.mount("/", Servlet, self, state_token)
-        server
-      end
-    end
-
-    private
-
-    def initiate_authentication(url)
-      @server_thread = Thread.new { server.start }
-      params = {
-        client_id: client_id,
-        scope: scopes,
-        redirect_uri: REDIRECT_HOST,
-        state: state_token,
-        response_type: :code,
-      }
-      params.merge!(challange_params) if secret.nil?
-      uri = URI.parse("#{url}#{auth_path}")
-      uri.query = URI.encode_www_form(params.merge(options))
-      output_authentication_info(uri)
-    end
-
-    def output_authentication_info(uri)
-      login_location = if service == "admin"
-        ctx.message("core.oauth.location.admin")
-      elsif Shopifolk.acting_as_shopify_organization?
-        ctx.message("core.oauth.location.shopifolk")
-      else
-        ctx.message("core.oauth.location.partner")
-      end
-      ctx.puts(ctx.message("core.oauth.authentication_required", login_location))
-      ctx.open_url!(uri)
-    end
-
-    def receive_access_code
-      @access_code ||= begin
-        @server_thread.join(240)
-        raise Error, ctx.message("core.oauth.error.timeout") if response_query.nil?
-        raise Error, response_query["error_description"] unless response_query["error"].nil?
-        response_query["code"]
-      end
-    end
-
-    def request_access_token(url, code:)
-      resp = post_token_request(
-        "#{url}#{token_path}",
-        {
-          grant_type: :authorization_code,
-          code: code,
-          redirect_uri: REDIRECT_HOST,
-          client_id: client_id,
-        }.merge(confirmation_param)
-      )
-      store.set(
-        "#{service}_access_token".to_sym => resp["access_token"],
-        "#{service}_refresh_token".to_sym => resp["refresh_token"],
-      )
-    end
-
-    def refresh_access_token(url)
-      return false if !store.exists?("#{service}_access_token".to_sym) ||
-        !store.exists?("#{service}_refresh_token".to_sym)
-      refresh_token(url)
-      request_exchange_token(url) if should_exchange
-      true
-    rescue
-      store.del("#{service}_access_token".to_sym, "#{service}_refresh_token".to_sym)
-      false
-    end
-
-    def refresh_token(url)
-      resp = post_token_request(
-        "#{url}#{token_path}",
-        grant_type: :refresh_token,
-        access_token: store.get("#{service}_access_token".to_sym),
-        refresh_token: store.get("#{service}_refresh_token".to_sym),
-        client_id: client_id,
-      )
-      store.set(
-        "#{service}_access_token".to_sym => resp["access_token"],
-        "#{service}_refresh_token".to_sym => resp["refresh_token"],
-      )
-    end
-
-    def refresh_exchange_token(url)
-      return false if !should_exchange || !store.exists?("#{service}_exchange_token".to_sym)
-      request_exchange_token(url)
-      true
-    rescue
-      store.del("#{service}_exchange_token".to_sym)
-      false
-    end
-
-    def request_exchange_token(url)
-      resp = post_token_request(
-        "#{url}#{token_path}",
-        grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
-        requested_token_type: "urn:ietf:params:oauth:token-type:access_token",
-        subject_token_type: "urn:ietf:params:oauth:token-type:access_token",
-        client_id: client_id,
-        audience: request_exchange,
-        scope: scopes,
-        subject_token: store.get("#{service}_access_token".to_sym),
-      )
-      store.set("#{service}_exchange_token".to_sym => resp["access_token"])
-    end
-
-    def post_token_request(url, params)
-      uri = URI.parse(url)
-      https = Net::HTTP.new(uri.host, uri.port)
-      https.use_ssl = true
-      request = Net::HTTP::Post.new(uri.path)
-      request["User-Agent"] = "Shopify App CLI #{::ShopifyCli::VERSION}"
-      request.body = URI.encode_www_form(params)
-      res = https.request(request)
-      raise Error, JSON.parse(res.body)["error_description"] unless res.is_a?(Net::HTTPSuccess)
-      JSON.parse(res.body)
-    end
-
-    def challange_params
-      {
-        code_challenge: code_challenge,
-        code_challenge_method: "S256",
-      }
-    end
-
-    def confirmation_param
-      if secret.nil?
-        { code_verifier: code_verifier }
-      else
-        { client_secret: secret }
-      end
-    end
-
-    def should_exchange
-      !request_exchange.nil? && !request_exchange.empty?
-    end
-  end
-end