shopify-cli 1.11.0 → 2.0.0

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "thread"
+
+module ShopifyCli
+  module Theme
+    module DevServer
+      # Server-Sent events implementation for Rack.
+      # Based on https://gist.github.com/raggi/ff7971991297e5c8a1ce
+      class SSE
+        class Event < Struct.new(:data)
+          def to_s
+            "data: #{data}\n" \
+            "\n\n"
+          end
+        end
+
+        class Stream
+          def initialize(streams)
+            @streams = streams
+            @queue = Queue.new
+          end
+
+          def <<(event)
+            raise TypeError, "expected SSE::Event" unless event.is_a?(Event)
+            @queue << event
+          end
+
+          def each
+            while (event = @queue.pop)
+              yield event.to_s
+            end
+          end
+
+          def close
+            @streams.remove(self)
+            @queue << nil
+          end
+        end
+
+        class Streams
+          def initialize
+            @list = []
+          end
+
+          def size
+            @list.size
+          end
+
+          def new
+            stream = Stream.new(self)
+            @list << stream
+            stream
+          end
+
+          def remove(stream)
+            raise TypeError, "expected SSE::Stream" unless stream.is_a?(Stream)
+            @list.delete(stream)
+          end
+
+          def broadcast(data)
+            raise TypeError, "expected String" unless data.is_a?(String)
+            @list.each do |stream|
+              stream << Event.new(data)
+            end
+          end
+
+          def close
+            @list.each(&:close)
+            @list.clear
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require "listen"
+require "observer"
+
+module ShopifyCli
+  module Theme
+    module DevServer
+      # Watches for file changes and publish events to the theme
+      class Watcher
+        include Observable
+
+        def initialize(ctx, theme:, syncer:, ignore_filter: nil)
+          @ctx = ctx
+          @theme = theme
+          @syncer = syncer
+          @ignore_filter = ignore_filter
+          @listener = Listen.to(@theme.root) do |modified, added, removed|
+            changed
+            notify_observers(modified, added, removed)
+          end
+
+          add_observer(self, :upload_files_when_changed)
+        end
+
+        def start
+          @listener.start
+        end
+
+        def stop
+          @listener.stop
+        end
+
+        def upload_files_when_changed(modified, added, removed)
+          modified_theme_files = filter_theme_files(modified + added)
+          if modified_theme_files.any?
+            @syncer.enqueue_updates(modified_theme_files)
+          end
+
+          removed_theme_files = filter_remote_files(removed)
+          if removed_theme_files.any?
+            @syncer.enqueue_deletes(removed_theme_files)
+          end
+        end
+
+        def filter_theme_files(files)
+          files
+            .select { |file| @theme.theme_file?(file) }
+            .reject { |file| @ignore_filter&.ignore?(file) }
+        end
+
+        def filter_remote_files(files)
+          files
+            .select { |file| @syncer.remote_file?(file) }
+            .reject { |file| @ignore_filter&.ignore?(file) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "stringio"
+
+module ShopifyCli
+  module Theme
+    module DevServer
+      # WEBrick will sometimes cause a fatal deadlock error on shutdown.
+      # The error happens because `Thread#join` is called without a timeout argument.
+      # We monkey-patch WEBrick to call `Thread#join(timeout)` before the existing
+      # `Thread#join`.
+      module WEBrickGenericServerThreadJoinWithTimeout
+        # Hook into a method called right before the threads are shutdown.
+        def cleanup_listener
+          # Force a Thread#join with a timeout to prevent any deadlock error on stop
+          Thread.list.each do |thread|
+            next unless thread[:WEBrickThread]
+            thread.join(2)
+            # Prevent the `join` call without a timeout inside WEBrick.
+            thread[:WEBrickThread] = false
+          end
+          super
+        end
+      end
+
+      # Base on Rack::Handler::WEBrick
+      class WebServer < ::WEBrick::HTTPServlet::AbstractServlet
+        def self.run(app, **options)
+          environment  = ENV["RACK_ENV"] || "development"
+          default_host = environment == "development" ? "localhost" : nil
+
+          if !options[:BindAddress] || options[:Host]
+            options[:BindAddress] = options.delete(:Host) || default_host
+          end
+          options[:Port] ||= 8080
+          if options[:SSLEnable]
+            require "webrick/https"
+          end
+
+          @server = ::WEBrick::HTTPServer.new(options)
+          @server.extend(WEBrickGenericServerThreadJoinWithTimeout)
+          @server.mount("/", WebServer, app)
+          yield @server if block_given?
+          @server.start
+        end
+
+        def self.valid_options
+          environment  = ENV["RACK_ENV"] || "development"
+          default_host = environment == "development" ? "localhost" : "0.0.0.0"
+
+          {
+            "Host=HOST" => "Hostname to listen on (default: #{default_host})",
+            "Port=PORT" => "Port to listen on (default: 8080)",
+          }
+        end
+
+        def self.shutdown
+          if @server
+            @server.shutdown
+            @server = nil
+          end
+        end
+
+        def initialize(server, app)
+          super(server)
+          @app = app
+        end
+
+        def service(req, res)
+          # res.rack = true
+          env = req.meta_vars
+          env.delete_if { |_k, v| v.nil? }
+
+          rack_input = StringIO.new(req.body.to_s)
+          rack_input.set_encoding(Encoding::BINARY)
+
+          env.update(
+            "rack.version"      => [1, 3],
+            "rack.input"        => rack_input,
+            "rack.errors"       => $stderr,
+            "rack.multithread"  => true,
+            "rack.multiprocess" => false,
+            "rack.run_once"     => false,
+            "rack.url_scheme"   => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http",
+            "rack.hijack?"      => true,
+            "rack.hijack"       => lambda { raise NotImplementedError, "only partial hijack is supported." },
+            "rack.hijack_io"    => nil
+          )
+
+          env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+          env["QUERY_STRING"] ||= ""
+          unless env["PATH_INFO"] == ""
+            path = req.request_uri.path
+            n = env["SCRIPT_NAME"].length
+            env["PATH_INFO"] = path[n, path.length - n]
+          end
+          env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env["PATH_INFO"]].join
+
+          status, headers, body = @app.call(env)
+
+          res.status = status.to_i
+          io_lambda = nil
+          headers.each do |k, vs|
+            if k == "rack.hijack"
+              io_lambda = vs
+            elsif k == "webrick.chunked"
+              res.chunked = true
+            elsif k.downcase == "set-cookie"
+              res.cookies.concat(vs.split("\n"))
+            else
+              # Since WEBrick won't accept repeated headers,
+              # merge the values per RFC 1945 section 4.2.
+              res[k] = vs.split("\n").join(", ")
+            end
+          end
+
+          if io_lambda
+            rd, wr = IO.pipe
+            res.body = rd
+            res.chunked = true
+            io_lambda.call(wr)
+            body.close if body.respond_to?(:close)
+          elsif body.respond_to?(:to_path)
+            res.body = ::File.open(body.to_path, "rb")
+            body.close if body.respond_to?(:close)
+          else
+            res.body = lambda do |out|
+              out.set_encoding(Encoding::BINARY) if out.respond_to?(:set_encoding)
+              body.each do |part|
+                out.write(part)
+              end
+              body.close if body.respond_to?(:close)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require_relative "theme"
+
+require "socket"
+require "securerandom"
+
+module ShopifyCli
+  module Theme
+    class DevelopmentTheme < Theme
+      def id
+        ShopifyCli::DB.get(:development_theme_id)
+      end
+
+      def name
+        ShopifyCli::DB.get(:development_theme_name) || generate_theme_name
+      end
+
+      def role
+        "development"
+      end
+
+      def ensure_exists!
+        if exists?
+          @ctx.debug("Using temporary development theme: ##{id} #{name}")
+        else
+          create
+          @ctx.debug("Created temporary development theme: #{@id}")
+          ShopifyCli::DB.set(development_theme_id: @id)
+        end
+      end
+
+      def exists?
+        return false unless id
+
+        ShopifyCli::AdminAPI.rest_request(
+          @ctx,
+          shop: shop,
+          path: "themes/#{id}.json",
+          api_version: "unstable",
+        )
+      rescue ShopifyCli::API::APIRequestNotFoundError
+        false
+      end
+
+      def delete
+        super if exists?
+        ShopifyCli::DB.del(:development_theme_id) if ShopifyCli::DB.exists?(:development_theme_id)
+        ShopifyCli::DB.del(:development_theme_name) if ShopifyCli::DB.exists?(:development_theme_name)
+      end
+
+      def self.delete(ctx)
+        new(ctx).delete
+      end
+
+      private
+
+      def generate_theme_name
+        hostname = Socket.gethostname.split(".").shift
+        hash = SecureRandom.hex(3)
+
+        theme_name = "Development (#{hash}-#{hostname})"
+
+        ShopifyCli::DB.set(development_theme_name: theme_name)
+
+        theme_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+require_relative "mime_type"
+
+module ShopifyCli
+  module Theme
+    class File < Struct.new(:path)
+      attr_reader :relative_path
+      attr_accessor :remote_checksum
+
+      def initialize(path, root)
+        super(Pathname.new(path))
+
+        # Path may be relative or absolute depending on the source.
+        # By converting both the path and the root to absolute paths, we
+        # can safely fetch a relative path.
+        @relative_path = self.path.expand_path.relative_path_from(root.expand_path)
+      end
+
+      def read
+        path.read
+      end
+
+      def write(content)
+        path.parent.mkpath unless path.parent.directory?
+        path.write(content)
+      end
+
+      def delete
+        path.delete
+      end
+
+      def exist?
+        path.exist?
+      end
+
+      def mime_type
+        @mime_type ||= MimeType.by_filename(relative_path)
+      end
+
+      def text?
+        mime_type.text?
+      end
+
+      def liquid?
+        path.extname == ".liquid"
+      end
+
+      def json?
+        path.extname == ".json"
+      end
+
+      def template?
+        relative_path.to_s.start_with?("templates/")
+      end
+
+      def checksum
+        content = read
+        if mime_type.json?
+          # Normalize JSON to match backend
+          begin
+            content = normalize_json(content)
+          rescue JSON::JSONError
+            # Fallback to using the raw content
+          end
+        end
+        Digest::MD5.hexdigest(content)
+      end
+
+      # Make it possible to check whether a given File is within a list of Files with `include?`,
+      # some of which may be relative paths while others are absolute paths.
+      def ==(other)
+        relative_path == other.relative_path
+      end
+
+      private
+
+      def normalize_json(content)
+        parsed = JSON.parse(content)
+
+        if template?
+          JsonTemplateNormalizer.new.visit_document(parsed)
+        end
+
+        normalized = JSON.generate(parsed)
+        # Backend escapes forward slashes
+        normalized.gsub!(/\//, "\\/")
+        normalized
+      end
+
+      class JsonTemplateNormalizer
+        def visit_document(value)
+          visit_hash(value["sections"])
+        end
+
+        def visit_hash(hash)
+          return unless hash.is_a?(Hash)
+          hash.each do |_, value|
+            visit_value(value)
+          end
+        end
+
+        def visit_value(value)
+          # Reinsert settings to force the same ordering as in the backend
+          settings = value.delete("settings") || {}
+          value["settings"] = settings
+
+          visit_hash(value["blocks"])
+        end
+      end
+    end
+  end
+end