shopify-cli 1.14.0 → 2.0.0

data/lib/shopify-cli/partners_api/organizations.rb

@@ -26,6 +26,14 @@ module ShopifyCli
             org
           end
         end
+
+        def fetch_with_extensions(ctx, type)
+          resp = PartnersAPI.query(ctx, "all_orgs_with_extensions", type: type)
+          (resp&.dig("data", "organizations", "nodes") || []).map do |org|
+            org["apps"] = (org.dig("apps", "nodes") || [])
+            org
+          end
+        end
       end
     end
   end

data/lib/shopify-cli/project_commands.rb

@@ -0,0 +1,16 @@
+module ShopifyCli
+  class ProjectCommands < Command
+    def call(*)
+      @ctx.puts(self.class.help)
+    end
+
+    def self.help
+      project_type = name.split("::")[0].downcase
+      ShopifyCli::Context.message(
+        "#{project_type}.help",
+        ShopifyCli::TOOL_NAME,
+        subcommand_registry.command_names.join(" | ")
+      )
+    end
+  end
+end

data/lib/shopify-cli/project_type.rb

@@ -5,7 +5,6 @@ module ShopifyCli
     class << self
       attr_accessor :project_type,
         :project_name,
-        :project_creator_command_class,
         :project_load_shallow
 
       def repository
@@ -49,36 +48,6 @@ module ShopifyCli
         @project_name = name
       end
 
-      def creator(command_const)
-        @project_creator_command_class = command_const
-        ShopifyCli::Commands::Create.subcommand(command_const, @project_type)
-      end
-
-      def create_command
-        const_get(@project_creator_command_class)
-      end
-
-      def connector(command_const)
-        @project_connector_command_class = command_const
-        ShopifyCli::Commands::Connect.subcommand(command_const, @project_type)
-      end
-
-      def connect_command
-        if @project_connector_command_class.nil?
-          nil
-        else
-          const_get(@project_connector_command_class)
-        end
-      end
-
-      def register_command(const, cmd)
-        return if project_load_shallow
-        Context.new.abort(
-          Context.message("core.project_type.error.cannot_override_core", cmd, const)
-        ) if Commands.core_command?(cmd)
-        Commands.register(const, cmd)
-      end
-
       def register_task(task, name)
         return if project_load_shallow
         ShopifyCli::Tasks.register(task, name)

data/lib/shopify-cli/shopifolk.rb

@@ -11,8 +11,6 @@ module ShopifyCli
     FEATURE_NAME = "shopifolk"
 
     class << self
-      attr_writer :acting_as_shopify_organization
-
       ##
       # will return if the user appears to be a Shopify employee, based on several heuristics
       #
@@ -29,15 +27,16 @@ module ShopifyCli
       end
 
       def act_as_shopify_organization
-        @acting_as_shopify_organization = true
+        DB.set(acting_as_shopify_organization: true)
       end
 
       def acting_as_shopify_organization?
-        !!(@acting_as_shopify_organization || (Project.has_current? && Project.current.config["shopify_organization"]))
+        !!(DB.get(:acting_as_shopify_organization) ||
+        (Project.has_current? && Project.current.config["shopify_organization"]))
       end
 
       def reset
-        @acting_as_shopify_organization = nil
+        DB.del(:acting_as_shopify_organization)
       end
     end
 
@@ -72,12 +71,10 @@ module ShopifyCli
     end
 
     def ini
-      @ini ||= begin
-        if File.exist?(GCLOUD_CONFIG_FILE)
-          CLI::Kit::Ini
-            .new(GCLOUD_CONFIG_FILE, default_section: "[#{SECTION}]", convert_types: false)
-            .tap(&:parse).ini
-        end
+      @ini ||= if File.exist?(GCLOUD_CONFIG_FILE)
+        CLI::Kit::Ini
+          .new(GCLOUD_CONFIG_FILE, default_section: "[#{SECTION}]", convert_types: false)
+          .tap(&:parse).ini
       end
     end
   end

data/lib/shopify-cli/sub_command.rb

@@ -9,6 +9,7 @@ module ShopifyCli
         args = cmd.options.parse(@_options, args[1..-1] || [])
         return call_help(parent_command, command_name) if cmd.options.help
         run_prerequisites
+
         cmd.call(args, command_name)
       end
     end

data/lib/shopify-cli/tasks.rb

@@ -30,9 +30,12 @@ module ShopifyCli
       Registry.add(-> () { const_get(task) }, name)
     end
 
+    register :ConfirmStore, :confirm_store, "shopify-cli/tasks/confirm_store"
     register :CreateApiClient, :create_api_client, "shopify-cli/tasks/create_api_client"
+    register :EnsureAuthenticated, :ensure_authenticated, "shopify-cli/tasks/ensure_authenticated"
     register :EnsureEnv, :ensure_env, "shopify-cli/tasks/ensure_env"
     register :EnsureLoopbackURL, :ensure_loopback_url, "shopify-cli/tasks/ensure_loopback_url"
+    register :EnsureProjectType, :ensure_project_type, "shopify-cli/tasks/ensure_project_type"
     register :EnsureDevStore, :ensure_dev_store, "shopify-cli/tasks/ensure_dev_store"
     register :SelectOrgAndShop, :select_org_and_shop, "shopify-cli/tasks/select_org_and_shop"
     register :UpdateDashboardURLS, :update_dashboard_urls, "shopify-cli/tasks/update_dashboard_urls"

data/lib/shopify-cli/tasks/confirm_store.rb

@@ -0,0 +1,18 @@
+require "shopify_cli"
+
+module ShopifyCli
+  module Tasks
+    class ConfirmStore < ShopifyCli::Task
+      def call(ctx)
+        @ctx = ctx
+        store = ShopifyCli::AdminAPI.get_shop_or_abort(ctx)
+        if CLI::UI::Prompt.confirm(ctx.message("core.tasks.confirm_store.prompt", store), default: false)
+          ctx.puts(ctx.message("core.tasks.confirm_store.confirmation", store))
+        else
+          ctx.puts(ctx.message("core.tasks.confirm_store.cancelling"))
+          raise AbortSilent
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/tasks/create_api_client.rb

@@ -4,7 +4,7 @@ module ShopifyCli
   module Tasks
     class CreateApiClient < ShopifyCli::Task
       VALID_APP_TYPES = %w(public custom)
-      DEFAULT_APP_URL = "https://shopify.github.io/shopify-app-cli/help/start-app/"
+      DEFAULT_APP_URL = "https://shopify.github.io/shopify-cli/help/start-app/"
 
       def call(ctx, org_id:, title:, type:)
         resp = ShopifyCli::PartnersAPI.query(
@@ -14,7 +14,7 @@ module ShopifyCli
           title: title,
           type: type,
           app_url: DEFAULT_APP_URL,
-          redir: [OAuth::REDIRECT_HOST]
+          redir: [IdentityAuth::REDIRECT_HOST]
         )
 
         unless resp

data/lib/shopify-cli/tasks/ensure_authenticated.rb

@@ -0,0 +1,13 @@
+require "shopify_cli"
+
+module ShopifyCli
+  module Tasks
+    class EnsureAuthenticated < ShopifyCli::Task
+      def call(ctx)
+        ctx.abort(
+          ctx.message("core.identity_auth.login_prompt", ShopifyCli::TOOL_NAME)
+        ) unless ShopifyCli::IdentityAuth::IDENTITY_ACCESS_TOKENS.all? { |key| ShopifyCli::DB.exists?(key) }
+      end
+    end
+  end
+end

data/lib/shopify-cli/tasks/ensure_loopback_url.rb

@@ -5,7 +5,7 @@ module ShopifyCli
         @ctx = ctx
         api_key = Project.current.env.api_key
         result = ShopifyCli::PartnersAPI.query(ctx, "get_app_urls", apiKey: api_key)
-        loopback = OAuth::REDIRECT_HOST
+        loopback = IdentityAuth::REDIRECT_HOST
         app = result["data"]["app"]
         urls = app["redirectUrlWhitelist"]
         if urls.grep(/#{loopback}/).empty?

data/lib/shopify-cli/tasks/ensure_project_type.rb

@@ -0,0 +1,12 @@
+require "shopify_cli"
+
+module ShopifyCli
+  module Tasks
+    class EnsureProjectType < ShopifyCli::Task
+      def call(ctx, project_type)
+        return true if project_type.to_sym == ShopifyCli::Project.current_project_type
+        ctx.abort(ctx.message("core.tasks.ensure_project_type.wrong_project_type", project_type))
+      end
+    end
+  end
+end

data/lib/shopify-cli/tasks/select_org_and_shop.rb

@@ -8,9 +8,6 @@ module ShopifyCli
       def call(ctx, organization_id: nil, shop_domain: nil)
         @ctx = ctx
         return response(organization_id.to_i, shop_domain) unless organization_id.nil? || shop_domain.nil?
-        if Shopifolk.check && wants_to_run_against_shopify_org?
-          Shopifolk.act_as_shopify_organization
-        end
         org = get_organization(organization_id)
         unless Shopifolk.acting_as_shopify_organization?
           shop_domain ||= get_shop_domain(org)

data/lib/shopify-cli/theme/dev_server.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require_relative "development_theme"
+require_relative "ignore_filter"
+require_relative "syncer"
+
+require_relative "dev_server/hot_reload"
+require_relative "dev_server/header_hash"
+require_relative "dev_server/local_assets"
+require_relative "dev_server/proxy"
+require_relative "dev_server/sse"
+require_relative "dev_server/watcher"
+require_relative "dev_server/web_server"
+require_relative "dev_server/certificate_manager"
+
+require "pathname"
+
+module ShopifyCli
+  module Theme
+    module DevServer
+      class << self
+        attr_accessor :ctx
+
+        def start(ctx, root, port: 9292, silent: false)
+          @ctx = ctx
+          theme = DevelopmentTheme.new(ctx, root: root)
+          ignore_filter = IgnoreFilter.from_path(root)
+          @syncer = Syncer.new(ctx, theme: theme, ignore_filter: ignore_filter)
+          watcher = Watcher.new(ctx, theme: theme, syncer: @syncer, ignore_filter: ignore_filter)
+
+          # Setup the middleware stack. Mimics Rack::Builder / config.ru, but in reverse order
+          @app = Proxy.new(ctx, theme: theme, syncer: @syncer)
+          @app = LocalAssets.new(ctx, @app, theme: theme)
+          @app = HotReload.new(ctx, @app, theme: theme, watcher: watcher, ignore_filter: ignore_filter)
+          stopped = false
+
+          theme.ensure_exists!
+
+          trap("INT") do
+            stopped = true
+            stop
+          end
+
+          CLI::UI::Frame.open(@ctx.message("theme.serve.serve")) do
+            ctx.print_task("Syncing theme ##{theme.id} on #{theme.shop}")
+            @syncer.start_threads
+            if silent
+              @syncer.upload_theme!(delay_low_priority_files: true)
+            else
+              @syncer.upload_theme_with_progress_bar!(delay_low_priority_files: true)
+            end
+
+            return if stopped
+
+            ctx.puts("")
+            ctx.puts("Serving #{theme.root}")
+            ctx.puts("")
+            ctx.open_url!("http://127.0.0.1:#{port}")
+            ctx.puts("")
+            ctx.puts("Customize this theme in the Online Store Editor:")
+            ctx.puts("{{green:#{theme.editor_url}}}")
+            ctx.puts("")
+            ctx.puts("Share this theme preview:")
+            ctx.puts("{{green:#{theme.preview_url}}}")
+            ctx.puts("")
+            ctx.puts("(Use Ctrl-C to stop)")
+          end
+
+          logger = if ctx.debug?
+            WEBrick::Log.new(nil, WEBrick::BasicLog::INFO)
+          else
+            WEBrick::Log.new(nil, WEBrick::BasicLog::FATAL)
+          end
+
+          watcher.start
+          WebServer.run(
+            @app,
+            Port: port,
+            Logger: logger,
+            AccessLog: [],
+          )
+          watcher.stop
+
+        rescue ShopifyCli::API::APIRequestForbiddenError,
+               ShopifyCli::API::APIRequestUnauthorizedError
+          @ctx.abort("You are not authorized to edit themes on #{theme.shop}.\n" \
+                     "Make sure you are a user of that store, and allowed to edit themes.")
+        end
+
+        def stop
+          @ctx.puts("Stopping ...")
+          @app.close
+          @syncer.shutdown
+          WebServer.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/theme/dev_server/certificate_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ShopifyCli
+  module Theme
+    module DevServer
+      class CertificateManager
+        attr_reader :ctx, :domain_name, :certificate, :private_key
+
+        ISSUER_EXTENSIONS = [
+          ["subjectKeyIdentifier", "hash", false],
+          ["authorityKeyIdentifier", "keyid:always", false],
+        ]
+
+        def initialize(ctx, domain_name)
+          @ctx = ctx
+          @domain_name = domain_name
+        end
+
+        def find_or_create_certificates!
+          @private_key = if (private_key_pem = ShopifyCli::DB.get(:ssl_private_key))
+            OpenSSL::PKey::RSA.new(private_key_pem)
+          else
+            OpenSSL::PKey::RSA.new(2048)
+          end
+
+          @certificate = if (certificate_pem = ShopifyCli::DB.get(:ssl_certificate))
+            OpenSSL::X509::Certificate.new(certificate_pem)
+          else
+            x509_certificate = build_x509_certificate
+
+            sign_certificate!(x509_certificate)
+
+            x509_certificate
+          end
+
+          ShopifyCli::DB.set(ssl_certificate: certificate.to_pem)
+          ShopifyCli::DB.set(ssl_private_key: private_key.to_pem)
+        end
+
+        private
+
+        def build_x509_certificate
+          certificate = OpenSSL::X509::Certificate.new
+
+          certificate.public_key = private_key.public_key
+          certificate.subject = subject
+          certificate.version = 2
+          certificate.serial = 0x0
+
+          certificate.not_before = Time.now.utc
+          certificate.not_after = Time.now.utc + 365 * 24 * 60 * 60
+
+          certificate
+        end
+
+        def sign_certificate!(certificate)
+          ef = OpenSSL::X509::ExtensionFactory.new
+
+          ef.subject_certificate = certificate
+          ef.issuer_certificate = certificate
+
+          ISSUER_EXTENSIONS.each do |args|
+            certificate.add_extension(ef.create_extension(*args))
+          end
+
+          certificate.add_extension(ef.create_extension("subjectAltName", "DNS:#{@domain_name}", false))
+
+          certificate.sign(private_key, OpenSSL::Digest.new("SHA256"))
+        end
+
+        def subject
+          OpenSSL::X509::Name.parse("/CN=#{@domain_name}/")
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/theme/dev_server/header_hash.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ShopifyCli
+  module Theme
+    module DevServer
+      # Based on Rack::HeaderHash
+      class HeaderHash < Hash
+        def self.[](headers)
+          if headers.is_a?(HeaderHash) && !headers.frozen?
+            headers
+          else
+            new(headers)
+          end
+        end
+
+        def initialize(hash = {})
+          super()
+          @names = {}
+          hash.each { |k, v| self[k] = v }
+        end
+
+        # on dup/clone, we need to duplicate @names hash
+        def initialize_copy(other)
+          super
+          @names = other.names.dup
+        end
+
+        # on clear, we need to clear @names hash
+        def clear
+          super
+          @names.clear
+        end
+
+        def each
+          super do |k, v|
+            yield(k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v)
+          end
+        end
+
+        def to_hash
+          hash = {}
+          each { |k, v| hash[k] = v }
+          hash
+        end
+
+        def [](k)
+          super(k) || super(@names[k.downcase])
+        end
+
+        def []=(k, v)
+          canonical = k.downcase.freeze
+          # .delete is expensive, don't invoke it unless necessary
+          delete(k) if @names[canonical] && @names[canonical] != k
+          @names[canonical] = k
+          super(k, v)
+        end
+
+        def delete(k)
+          canonical = k.downcase
+          result = super(@names.delete(canonical))
+          result
+        end
+
+        def include?(k)
+          super || @names.include?(k.downcase)
+        end
+
+        alias_method :has_key?, :include?
+        alias_method :member?, :include?
+        alias_method :key?, :include?
+
+        def merge!(other)
+          other.each { |k, v| self[k] = v }
+          self
+        end
+
+        def merge(other)
+          hash = dup
+          hash.merge!(other)
+        end
+
+        def replace(other)
+          clear
+          other.each { |k, v| self[k] = v }
+          self
+        end
+
+        protected
+
+        attr_reader :names
+      end
+    end
+  end
+end