@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/lib/project_types/extension/models/specification_handlers/theme_app_extension.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+require "base64"
+require "json"
+require "shopify_cli/theme/extension/dev_server"
+
+module Extension
+  module Models
+    module SpecificationHandlers
+      class ThemeAppExtension < Default
+        SUPPORTED_BUCKETS = %w(assets blocks snippets locales)
+        BUNDLE_SIZE_LIMIT = 10 * 1024 * 1024 # 10MB
+        LIQUID_SIZE_LIMIT = 100 * 1024 # 100kb
+        SUPPORTED_ASSET_EXTS = %w(.jpg .js .css .png .svg)
+        SUPPORTED_LOCALE_EXTS = %w(.json)
+
+        def create(directory_name, context, getting_started: false)
+          context.root = File.join(context.root, directory_name)
+
+          if getting_started
+            ShopifyCLI::Git.clone("https://github.com/Shopify/theme-extension-getting-started", context.root)
+            context.rm_r(".git")
+          else
+            FileUtils.makedirs(SUPPORTED_BUCKETS.map { |b| File.join(context.root, b) })
+          end
+        end
+
+        def config(context)
+          current_size = 0
+          current_liquid_size = 0
+          Dir.chdir(context.root) do
+            Dir["**/*"].select { |filename| File.file?(filename) && validate(filename) }
+              .map do |filename|
+                dirname = File.dirname(filename)
+                if dirname == "assets"
+                  # Assets should be read as binary data, since they could be images
+                  mode = "rb"
+                  encoding = "BINARY"
+                else
+                  # Other assets should be treated as UTF-8 encoded text
+                  mode = "rt"
+                  encoding = "UTF-8"
+
+                  if dirname == "snippets" || dirname == "blocks"
+                    current_liquid_size += File.size(filename)
+                  end
+                end
+                current_size += File.size(filename)
+                if current_size > BUNDLE_SIZE_LIMIT
+                  raise Extension::Errors::BundleTooLargeError,
+                    "Total size of all files must be less than #{CLI::Kit::Util.to_filesize(BUNDLE_SIZE_LIMIT)}"
+                end
+                if current_liquid_size > LIQUID_SIZE_LIMIT
+                  raise Extension::Errors::BundleTooLargeError,
+                    "Total size of all liquid must be less than #{CLI::Kit::Util.to_filesize(LIQUID_SIZE_LIMIT)}"
+                end
+                [filename, Base64.encode64(File.read(filename, mode: mode, encoding: encoding))]
+              end
+              .yield_self do |encoded_files_by_name|
+                { "theme_extension" => { "files" => encoded_files_by_name.to_h } }
+              end
+          end
+        end
+
+        def name
+          "Theme App Extension"
+        end
+
+        def choose_port?(_ctx)
+          false
+        end
+
+        def establish_tunnel?(_ctx)
+          false
+        end
+
+        def serve(**options)
+          @ctx = options[:context]
+          root = options[:context]&.root
+          project = options[:project]
+          properties = options
+            .slice(:port, :theme)
+            .compact
+            .merge({
+              project: project,
+              specification_handler: self,
+            })
+
+          ShopifyCLI::Theme::Extension::DevServer.start(@ctx, root, **properties)
+        end
+
+        private
+
+        def validate(filename)
+          dirname = File.dirname(filename)
+          # Skip files in the root of the directory tree
+          return false if dirname == "."
+
+          unless SUPPORTED_BUCKETS.include?(dirname)
+            raise Extension::Errors::InvalidFilenameError, "Invalid directory: #{dirname}"
+          end
+
+          ext = File.extname(filename)
+          if dirname == "assets"
+            unless SUPPORTED_ASSET_EXTS.include?(ext)
+              raise Extension::Errors::InvalidFilenameError,
+                "Invalid filename: #{filename}; #{ext} is not supported"
+            end
+          elsif dirname == "locales"
+            unless SUPPORTED_LOCALE_EXTS.include?(ext)
+              raise Extension::Errors::InvalidFilenameError,
+                "Invalid filename: #{filename}; Only #{SUPPORTED_LOCALE_EXTS.join(", ")} allowed in #{dirname}"
+            end
+          elsif ext != ".liquid"
+            raise Extension::Errors::InvalidFilenameError,
+              "Invalid filename: #{filename}; Only .liquid allowed in #{dirname}"
+          end
+          true
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/models/specification_handlers/web_pixel_extension.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require "base64"
+require "fileutils"
+require "json"
+require_relative "web_pixel_extension_utils/script_config"
+require_relative "web_pixel_extension_utils/script_config_repository"
+
+module Extension
+  module Models
+    module SpecificationHandlers
+      class WebPixelExtension < Default
+        SCRIPT_FILE = "build/main.js"
+
+        def name
+          "Web Pixel Extension"
+        end
+
+        def read_configuration
+        end
+
+        def access_config_property(context, ext_config, key, &process_value)
+          context.abort(context.message("core.extension.push.web_pixel_extension.error.missing_config_key_error",
+            key)) unless ext_config.key?(key)
+
+          begin
+            process_value.nil? ? ext_config[key] : process_value.call(ext_config[key])
+          rescue StandardError
+            context.abort(context.message("core.extension.push.web_pixel_extension.error.invalid_config_value_error",
+              key))
+          end
+        end
+
+        def config(context)
+          begin
+            ext_config = WebPixelExtensionUtils::ScriptConfigYmlRepository.new(ctx: context).get!.content
+          rescue StandardError
+            context.abort(context.message("core.extension.push.web_pixel_extension.error.file_read_error",
+              WebPixelExtensionUtils::ScriptConfigYmlRepository.filename))
+          end
+
+          begin
+            script_contents = File.read(File.join(context.root, SCRIPT_FILE)).chomp
+          rescue
+            context.abort(context.message("core.extension.push.web_pixel_extension.error.file_read_error", SCRIPT_FILE))
+          end
+          {
+            runtime_context: access_config_property(context, ext_config, "runtime_context"),
+            serialized_script: Base64.strict_encode64(script_contents),
+            runtime_configuration_definition: access_config_property(context, ext_config,
+              "configuration", &:to_json),
+            config_version: access_config_property(context, ext_config,
+              "version", &:to_s),
+          }
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/models/specification_handlers/web_pixel_extension_utils/script_config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module SpecificationHandlers
+      module WebPixelExtensionUtils
+        class ScriptConfig
+          attr_reader :content, :version, :configuration, :filename
+
+          REQUIRED_FIELDS = %w(version)
+
+          def initialize(content:, filename:)
+            @filename = filename
+            validate_content!(content)
+            @content = content
+            @version = @content["version"].to_s
+            @configuration = @content["configuration"]
+          end
+
+          private
+
+          def validate_content!(content)
+            REQUIRED_FIELDS.each do |field|
+              if content[field].nil?
+                raise "invalid field:#{field}, filename:#{filename}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/models/specification_handlers/web_pixel_extension_utils/script_config_repository.rb

@@ -0,0 +1,75 @@
+require_relative "script_config"
+module Extension
+  module Models
+    module SpecificationHandlers
+      module WebPixelExtensionUtils
+        class ScriptConfigRepository
+          include SmartProperties
+          property! :ctx, accepts: ShopifyCLI::Context
+
+          def active?
+            ctx.file_exist?(filename)
+          end
+
+          def get!
+            raise RuntimeError.new("NoScriptConfigFile"), filename unless active?
+
+            content = ctx.read(filename)
+            hash = file_content_to_hash(content)
+
+            from_h(hash)
+          end
+
+          def filename
+            raise NotImplementedError
+          end
+
+          private
+
+          def from_h(hash)
+            Extension::Models::SpecificationHandlers::WebPixelExtensionUtils::ScriptConfig.new(content: hash,
+              filename: filename)
+          end
+
+          def file_content_to_hash(file_content)
+            raise NotImplementedError
+          end
+
+          def hash_to_file_content(hash)
+            raise NotImplementedError
+          end
+        end
+
+        class ScriptConfigYmlRepository < ScriptConfigRepository
+          def self.filename
+            "extension.config.yml"
+          end
+
+          def filename
+            ScriptConfigYmlRepository.filename
+          end
+
+          private
+
+          def file_content_to_hash(file_content)
+            begin
+              hash = YAML.load(file_content)
+            rescue Psych::SyntaxError
+              raise parse_error
+            end
+            raise parse_error unless hash.is_a?(Hash)
+            hash
+          end
+
+          def hash_to_file_content(hash)
+            YAML.dump(hash)
+          end
+
+          def parse_error
+            RuntimeError.new("ScriptConfigParseError #{filename}, serialization_format: \"YAML\" ")
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/models/specifications.rb

@@ -0,0 +1,89 @@
+module Extension
+  module Models
+    class Specifications
+      include SmartProperties
+
+      property! :custom_handler_root,
+        accepts: ->(d) { File.directory?(d) },
+        default: -> { File.expand_path("lib/project_types/extension/models/specification_handlers", ShopifyCLI::ROOT) }
+
+      property! :custom_handler_namespace,
+        accepts: ->(m) { m.respond_to?(:const_get) },
+        default: -> { ::Extension::Models::SpecificationHandlers }
+
+      property! :fetch_specifications,
+        accepts: ->(p) { p.respond_to?(:to_proc) }
+
+      def [](identifier)
+        handlers[identifier]
+      end
+
+      def valid?(identifier)
+        handlers.key?(identifier)
+      end
+
+      def each(&block)
+        handlers.values.each(&block)
+      end
+
+      def none?
+        each.none?
+      end
+
+      protected
+
+      def handlers
+        @handlers ||= fetch_specifications_and_build_handlers
+      end
+
+      private
+
+      def fetch_specifications_and_build_handlers
+        ShopifyCLI::Result
+          .call(&fetch_specifications)
+          .map(&ShopifyCLI::TransformDataStructure.new(symbolize_keys: true, underscore_keys: true))
+          .then(&method(:select_cli_extensions))
+          .then(&Tasks::ConfigureFeatures)
+          .then(&Tasks::ConfigureOptions)
+          .then(&method(:ensure_legacy_compatibility))
+          .then(&method(:build_specifications))
+          .then(&method(:require_handler_implementations))
+          .then(&method(:instantiate_specification_handlers))
+          .unwrap { |err| raise err }
+      end
+
+      def require_handler_implementations(specifications)
+        specifications.each do |s|
+          implementation_file = File.join(custom_handler_root, "#{s.identifier}.rb")
+          require(implementation_file) if File.file?(implementation_file)
+        end
+      end
+
+      def instantiate_specification_handlers(specifications)
+        specifications.each_with_object({}) do |specification, handlers|
+          ShopifyCLI::ResolveConstant.call(specification.identifier, namespace: custom_handler_namespace)
+            .rescue { |error| error.is_a?(NameError) ? SpecificationHandlers::Default : raise(error) }
+            .then { |handler_class| handler_class.new(specification) }
+            .unwrap { |error| raise error }
+            .yield_self { |handler| handlers[handler.identifier] = handler }
+        end
+      end
+
+      def ensure_legacy_compatibility(specification_attribute_sets)
+        specification_attribute_sets.each do |attributes|
+          next unless attributes.fetch(:identifier) == "subscription_management"
+          attributes[:identifier] = "product_subscription"
+          attributes[:graphql_identifier] = "SUBSCRIPTION_MANAGEMENT"
+        end
+      end
+
+      def build_specifications(specification_attribute_sets)
+        specification_attribute_sets.map { |attributes| Models::Specification.new(**attributes) }
+      end
+
+      def select_cli_extensions(specification_attribute_sets)
+        specification_attribute_sets.select { |attributes| attributes.dig(:options, :management_experience) == "cli" }
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/models/validation_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    class ValidationError
+      include SmartProperties
+
+      IS_VALIDATION_ERROR_LIST = -> (errors) do
+        errors.is_a?(Array) && errors.all? { |error| IS_VALIDATION_ERROR.call(error) }
+      end
+      IS_VALIDATION_ERROR = -> (error) { error.is_a?(ValidationError) }
+
+      property! :field, accepts: -> (fields) { fields.all? { |field| field.is_a?(String) } }
+      property! :message, accepts: String
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/models/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    class Version
+      include SmartProperties
+
+      property! :registration_id, accepts: Integer
+      property! :last_user_interaction_at, accepts: Time
+      property  :context, accepts: String
+      property  :location, accepts: String
+      property :validation_errors, accepts: Models::ValidationError::IS_VALIDATION_ERROR_LIST, default: -> { [] }
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/tasks/choose_next_available_port.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "shopify_cli"
+require "socket"
+
+module Extension
+  module Tasks
+    class ChooseNextAvailablePort
+      include ShopifyCLI::MethodObject
+
+      property! :from
+      property! :to, default: -> { from + 10 }
+      property! :host, default: "127.0.0.1"
+
+      def call
+        available_port = port_range(from: from, to: to).find { |p| available?(host, p) }
+        raise ArgumentError, "Ports between #{from} and #{to} are unavailable" if available_port.nil?
+        available_port
+      end
+
+      private
+
+      def port_range(from:, to:)
+        (from..to)
+      end
+
+      def available?(host, port)
+        Socket.tcp(host, port, connect_timeout: 1) do |socket|
+          socket.close
+          false
+        end
+      rescue Errno::ECONNREFUSED
+        true
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/tasks/configure_features.rb

@@ -0,0 +1,73 @@
+module Extension
+  module Tasks
+    class ConfigureFeatures
+      include ShopifyCLI::MethodObject
+
+      class Error < RuntimeError; end
+      class UnknownSurfaceArea < Error; end
+      class UnspecifiedSurfaceArea < Error; end
+
+      def call(specification_attribute_sets)
+        specification_attribute_sets.each do |attributes|
+          argo_configuration = extract_argo_configuration(attributes)
+          next if argo_configuration.nil?
+          surface_area = extract_surface_area(argo_configuration)
+          if known_surface_area?(surface_area)
+            surface_area_configuration = fetch_surface_area_configuration(surface_area)
+            argo_configuration.merge!(surface_area_configuration)
+          else
+            clear_argo_configuration(attributes)
+          end
+        end
+      end
+
+      private
+
+      def known_surface_area?(surface_area)
+        surface_area_configurations.keys.include?(surface_area.to_sym)
+      end
+
+      def extract_argo_configuration(attributes)
+        attributes.dig(:features, :argo)
+      end
+
+      def extract_surface_area(argo_configuration)
+        argo_configuration.fetch(:surface) do
+          raise UnspecifiedSurfaceArea, "Argo configuration does not specify surface area"
+        end
+      end
+
+      def fetch_surface_area_configuration(surface_area)
+        surface_area_configurations.fetch(surface_area.to_sym) do
+          raise UnknownSurfaceArea, "Unknown surface area: #{surface_area}"
+        end
+      end
+
+      def clear_argo_configuration(attributes)
+        attributes[:name] = "#{attributes[:name]} (Warning: surface area not configured properly)"
+        attributes[:features][:argo] = nil
+      end
+
+      def surface_area_configurations
+        {
+          admin: {
+            git_template: "https://github.com/Shopify/admin-ui-extensions-template",
+            renderer_package_name: "@shopify/admin-ui-extensions",
+            required_fields: [:shop, :api_key],
+            cli_package_name: "@shopify/admin-ui-extensions-run",
+          },
+          checkout: {
+            git_template: "https://github.com/Shopify/checkout-ui-extensions-template",
+            renderer_package_name: "@shopify/checkout-ui-extensions",
+            required_fields: [:shop],
+            cli_package_name: "@shopify/checkout-ui-extensions-run",
+          },
+          point_of_sale: {
+            git_template: "",
+            renderer_package_name: "@shopify/retail-ui-extensions",
+          },
+        }
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/tasks/configure_options.rb

@@ -0,0 +1,21 @@
+module Extension
+  module Tasks
+    class ConfigureOptions
+      include ShopifyCLI::MethodObject
+
+      def call(specification_attribute_sets)
+        specification_attribute_sets.each do |attributes|
+          attributes[:options] ||= {}
+          configure_skip_build(attributes)
+        end
+      end
+
+      private
+
+      def configure_skip_build(attributes)
+        attributes[:options].merge!(skip_build: attributes[:identifier] == "theme_app_extension" ||
+         attributes[:identifier] == "web_pixel_extension")
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/tasks/convert_server_config.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Extension
+  module Tasks
+    class ConvertServerConfig
+      include SmartProperties
+
+      property! :api_key, accepts: String
+      property! :context, accepts: ShopifyCLI::Context
+      property! :hash, accepts: Hash
+      property! :port, accepts: Integer
+      property! :registration_uuid, accepts: String
+      property  :resource_url, accepts: String
+      property! :store, accepts: String
+      property! :title, accepts: String
+      property  :tunnel_url, accepts: String
+      property! :type, accepts: String
+      property  :metafields, accepts: Array
+
+      DEFAULT_BUILD_DIR = "build"
+
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def call
+        context.abort(context.message("tasks.errors.parse_error")) if hash.nil?
+
+        renderer = Models::ServerConfig::DevelopmentRenderer.find(type)
+        extension = Models::ServerConfig::Extension.new(
+          uuid: registration_uuid,
+          type: type,
+          user: Models::ServerConfig::User.new,
+          development: Models::ServerConfig::Development.new(
+            build_dir: hash.dig("development", "build_dir") || DEFAULT_BUILD_DIR,
+            renderer: renderer,
+            entries: Models::ServerConfig::DevelopmentEntries.new(
+              main: hash.dig("development", "entries", "main") || determine_default_entry_main(project_directory),
+            )
+          ),
+          extension_points: hash.dig("extension_points"),
+          capabilities: Models::ServerConfig::Capabilities.new(
+            network_access: hash.dig("capabilities", "network_access") || false
+          ),
+          version: renderer ? version(renderer.name, context) : nil,
+          title: title,
+          metafields: metafields
+        )
+
+        unless resource_url.nil?
+          extension.development.resource = Models::ServerConfig::DevelopmentResource.new(url: resource_url)
+        end
+        server_config = Models::ServerConfig::Root.new(
+          extensions: [extension],
+          port: port,
+          public_url: tunnel_url,
+          store: store
+        )
+
+        unless api_key.nil?
+          server_config.app = Models::ServerConfig::App.new(api_key: api_key)
+        end
+
+        server_config
+      end
+
+      def version(renderer, context)
+        Tasks::FindPackageFromJson.call(renderer, context: context).version
+      end
+
+      private
+
+      def determine_default_entry_main(project_directory)
+        Dir.chdir(project_directory) do
+          Dir["src/*"].lazy.grep(/index.[jt]sx?/).first
+        end
+      end
+
+      def project_directory
+        ExtensionProject.current.directory
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/tasks/converters/app_converter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Extension
+  module Tasks
+    module Converters
+      module AppConverter
+        API_KEY_FIELD = "apiKey"
+        API_SECRET_KEYS_FIELD = "apiSecretKeys"
+        API_SECRET_FIELD = "secret"
+        TITLE_FIELD = "title"
+        ORGANIZATION_NAME_FIELD = "businessName"
+
+        def self.from_hash(hash, organization = {})
+          return nil if hash.nil?
+
+          Models::App.new(
+            api_key: hash[API_KEY_FIELD],
+            secret: hash[API_SECRET_KEYS_FIELD].first[API_SECRET_FIELD],
+            title: hash[TITLE_FIELD],
+            business_name: organization[ORGANIZATION_NAME_FIELD]
+          )
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/extension/tasks/converters/product_converter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Extension
+  module Tasks
+    module Converters
+      module ProductConverter
+        VARIANT_PATH = ["data", "products", "edges", 0, "node", "variants", "edges", 0, "node", "id"]
+
+        def self.from_hash(hash)
+          return nil if hash.nil?
+          variant = hash.dig(*VARIANT_PATH)
+          return unless variant
+          Models::Product.new(
+            variant_id: ShopifyCLI::API.gid_to_id(variant)
+          )
+        end
+      end
+    end
+  end
+end