@shopify/cli-kit 3.38.0 → 3.40.0

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module ServerConfig
+      class Base
+        def to_h
+          to_hash
+        end
+
+        def to_hash
+          is_hashable = ->(obj) { obj.respond_to?(:to_hash) }
+          is_collection_of_hashables = ->(obj) { obj.is_a?(Enumerable) && obj.all?(&is_hashable) }
+
+          self.class.properties.each.reduce({}) do |data, (_, property)|
+            data.merge(property.name.to_s => send(property.reader).yield_self do |value|
+              case value
+              when is_collection_of_hashables
+                value.map { |element| element.to_hash.transform_keys(&:to_s) }
+              when is_hashable
+                value.to_hash.transform_keys(&:to_s)
+              else
+                value
+              end
+            end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Extension
+  module Models
+    module ServerConfig
+      class Capabilities < Base
+        include SmartProperties
+
+        property :network_access, accepts: [true, false], default: false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Extension
+  module Models
+    module ServerConfig
+      class Development < Base
+        include SmartProperties
+        VALID_TEMPLATES = [
+          "javascript",
+          "javascript-react",
+          "typescript",
+          "typescript-react",
+        ]
+
+        CURRENT_DIRECTORY = "."
+
+        property  :root_dir, accepts: String, default: CURRENT_DIRECTORY
+        property! :build_dir, accepts: String, default: "build"
+        property  :template, accepts: VALID_TEMPLATES
+        property  :renderer, accepts: ServerConfig::DevelopmentRenderer
+        property  :entries, accepts: ServerConfig::DevelopmentEntries
+        property  :resource, accepts: ServerConfig::DevelopmentResource
+
+        def self.find(type)
+          case type.downcase
+          when "web_pixel_extension"
+            ["javascript"]
+          else
+            VALID_TEMPLATES
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module ServerConfig
+      class DevelopmentEntries < Base
+        include SmartProperties
+
+        JAVASCRIPT = "javascript"
+        JAVASCRIPT_REACT = "javascript-react"
+        TYPESCRIPT = "typescript"
+        TYPESCRIPT_REACT = "typescript-react"
+
+        VALID_ENTRY_POINTS = [
+          "src/index.js",
+          "src/index.jsx",
+          "src/index.ts",
+          "src/index.tsx",
+        ]
+
+        property! :main, accepts: VALID_ENTRY_POINTS
+
+        def self.find(template)
+          case template
+          when JAVASCRIPT
+            new(main: "src/index.js")
+          when JAVASCRIPT_REACT
+            new(main: "src/index.jsx")
+          when TYPESCRIPT
+            new(main: "src/index.ts")
+          when TYPESCRIPT_REACT
+            new(main: "src/index.tsx")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module ServerConfig
+      class DevelopmentRenderer < Base
+        include SmartProperties
+
+        VALID_RENDERERS = [
+          "@shopify/admin-ui-extensions",
+          "@shopify/post-purchase-ui-extensions",
+          "@shopify/checkout-ui-extensions",
+          "@shopify/retail-ui-extensions",
+        ]
+
+        property! :name, accepts: VALID_RENDERERS
+        property! :version, accepts: String, default: "latest"
+
+        def self.find(type)
+          case type.downcase
+          when "product_subscription"
+            new(name: "@shopify/admin-ui-extensions", version: "^1.0.1")
+          when "checkout_ui_extension"
+            new(name: "@shopify/checkout-ui-extensions", version: "^0.15.0")
+          when "checkout_post_purchase"
+            new(name: "@shopify/post-purchase-ui-extensions", version: "^0.13.2")
+          when "pos_ui_extension"
+            new(name: "@shopify/retail-ui-extensions", version: "^0.12.0")
+          when "web_pixel_extension"
+            nil
+          else
+            raise ArgumentError, "Unknown extension type: #{type}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module ServerConfig
+      class DevelopmentResource < Base
+        include SmartProperties
+
+        property! :url, accepts: String
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require "securerandom"
+
+module Extension
+  module Models
+    module ServerConfig
+      class Extension < Base
+        include SmartProperties
+
+        property! :uuid, accepts: String
+        property! :type, accepts: String
+        property! :user, accepts: ServerConfig::User
+        property! :development, accepts: ServerConfig::Development
+        property  :capabilities, accepts: ServerConfig::Capabilities
+        property  :extension_points, accepts: Array
+        property  :title, accepts: String
+        property  :description, accepts: String
+        property  :version, accepts: String
+        property  :metafields, accepts: Array
+
+        def self.build(uuid: "", template:, type:, root_dir:, **args)
+          renderer = ServerConfig::DevelopmentRenderer.find(type)
+          entry = ServerConfig::DevelopmentEntries.find(template)
+          new(
+            uuid: uuid.empty? ? generate_dev_uuid : uuid,
+            type: type.downcase,
+            user: ServerConfig::User.new,
+            development: ServerConfig::Development.new(
+              root_dir: root_dir,
+              template: template,
+              renderer: renderer,
+              entries: entry
+            ),
+            capabilities: ServerConfig::Capabilities.new(
+              network_access: false
+            ),
+            metafields: args.delete(:metafields)
+          )
+        end
+
+        def self.generate_dev_uuid
+          "dev-#{SecureRandom.uuid}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module ServerConfig
+      class Root < Base
+        include SmartProperties
+
+        property  :app, accepts: ServerConfig::App
+        property! :extensions, accepts: Array, default: -> { [] }
+        property! :port, accepts: Integer, default: 39351
+        property  :public_url, accepts: String
+        property  :store, accepts: String
+
+        def to_yaml
+          to_h.to_yaml.gsub("---\n", "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Extension
+  module Models
+    module ServerConfig
+      class User < Base
+        include SmartProperties
+        property! :metafields, accepts: Array, default: -> { [] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Extension
+  module Models
+    class Specification
+      include SmartProperties
+
+      module Features
+        class Argo
+          include SmartProperties
+
+          property! :surface, converts: :to_str
+          property! :renderer_package_name, converts: :to_str
+          property! :git_template, converts: :to_str
+          property! :required_fields, accepts: Array, default: -> { [] }
+          property! :required_shop_beta_flags, accepts: Array, default: -> { [] }
+          property! :cli_package_name, accepts: String, converts: :to_str, default: ""
+        end
+
+        def self.build(feature_set_attributes)
+          feature_set_attributes.each_with_object(OpenStruct.new) do |(identifier, feature_attributes), feature_set|
+            next if feature_attributes.nil?
+            feature_set[identifier] = ShopifyCLI::ResolveConstant
+              .call(identifier, namespace: Features)
+              .rescue { OpenStruct }
+              .then { |c| c.new(**feature_attributes) }
+              .unwrap { |error| raise(error) }
+          end
+        end
+      end
+
+      property! :identifier
+      property :name, converts: :to_str
+      property :graphql_identifier, converts: :to_str
+      property! :features, converts: Features.method(:build), default: -> { [] }
+      property! :options, converts: ->(options) { OpenStruct.new(options) }, default: -> { OpenStruct.new }
+
+      def graphql_identifier
+        super || identifier
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "base64"
+
+module Extension
+  module Models
+    module SpecificationHandlers
+      class CheckoutPostPurchase < Default
+        PERMITTED_CONFIG_KEYS = [:metafields]
+        RENDERER_PACKAGE_NAME = "@shopify/post-purchase-ui-extensions"
+
+        def config(context)
+          {
+            **Features::ArgoConfig.parse_yaml(context, PERMITTED_CONFIG_KEYS),
+            **argo.config(context, include_renderer_version: false),
+          }
+        end
+
+        protected
+
+        def argo
+          Features::Argo.new(
+            git_template: specification.features.argo.git_template,
+            renderer_package_name: RENDERER_PACKAGE_NAME
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module SpecificationHandlers
+      class CheckoutUiExtension < Default
+        L10N_ERROR_PREFIX = "core.extension.push.checkout_ui_extension.localization.error"
+        L10N_FILE_SIZE_LIMIT = 16 * 1024 # 16kb
+        L10N_BUNDLE_SIZE_LIMIT = 256 * 1024 # 256kb
+        LOCALE_CODE_FORMAT = %r{
+          \A
+          (?<language>[a-zA-Z]{2,3}) # Language tag
+          (?:
+           -
+           (?<region>[a-zA-Z]{2}) # Optional region subtag
+          )?
+          \z}x
+        PERMITTED_CONFIG_KEYS = [:extension_points, :metafields, :name, :capabilities]
+
+        def config(context)
+          {
+            **Features::ArgoConfig.parse_yaml(context, PERMITTED_CONFIG_KEYS),
+            **argo.config(context, include_renderer_version: false),
+            **localization(context),
+          }
+        end
+
+        def supplies_resource_url?
+          true
+        end
+
+        def build_resource_url(context:, shop:)
+          product = Tasks::GetProduct.call(context, shop)
+          return unless product
+          format("/cart/%<variant_id>d:%<quantity>d", variant_id: product.variant_id, quantity: 1)
+        end
+
+        private
+
+        def localization(context)
+          Dir.chdir(context.root) do
+            locale_filenames = Dir["locales/*"].select { |filename| valid_l10n_file?(filename) }
+            # Localization is optional
+            return {} if locale_filenames.empty?
+
+            validate_no_duplicate_locale(locale_filenames)
+            validate_total_size(locale_filenames)
+            default_locale = single_default_locale(locale_filenames)
+
+            locale_filenames.map do |filename|
+              locale = basename_for_locale_filename(filename)
+              [locale.to_sym, read_locale_file(filename)]
+            end
+              .yield_self do |encoded_files_by_locale|
+              {
+                localization: {
+                  default_locale: default_locale,
+                  translations: encoded_files_by_locale.to_h,
+                },
+              }
+            end
+          end
+        end
+
+        def read_locale_file(filename)
+          content = File.read(filename, mode: "rt", encoding: "bom|utf-8").strip
+          raise_invalid_encoding_error(filename) unless content.valid_encoding?
+          Base64.strict_encode64(content)
+        rescue ArgumentError
+          raise_invalid_encoding_error(filename)
+        end
+
+        def validate_no_duplicate_locale(locale_filenames)
+          duplicate_locale = locale_filenames
+            .map { |filename| basename_for_locale_filename(filename.downcase) }
+            .group_by { |locale| locale }
+            .detect { |_k, v| v.size > 1 }
+            &.first
+          raise(
+            ShopifyCLI::Abort,
+            ShopifyCLI::Context.message("#{L10N_ERROR_PREFIX}.duplicate_locale_code", duplicate_locale)
+          ) unless duplicate_locale.nil?
+        end
+
+        def validate_total_size(locale_filenames)
+          total_size = locale_filenames.sum { |filename| File.size(filename) }
+          if total_size > L10N_BUNDLE_SIZE_LIMIT
+            raise(
+              ShopifyCLI::Abort,
+              ShopifyCLI::Context.message(
+                "#{L10N_ERROR_PREFIX}.bundle_too_large",
+                CLI::Kit::Util.to_filesize(L10N_BUNDLE_SIZE_LIMIT)
+              )
+            )
+          end
+        end
+
+        def single_default_locale(locale_filenames)
+          default_locale_matches = locale_filenames.grep(/default/)
+          if default_locale_matches.size != 1
+            raise(ShopifyCLI::Abort, ShopifyCLI::Context.message("#{L10N_ERROR_PREFIX}.single_default_locale"))
+          end
+          basename_for_locale_filename(default_locale_matches.first)
+        end
+
+        def valid_l10n_file?(filename)
+          return false unless File.file?(filename)
+          return false unless File.dirname(filename) == "locales"
+
+          validate_file_extension(filename)
+          validate_file_locale_code(filename)
+          validate_file_size(filename)
+          validate_file_not_empty(filename)
+
+          true
+        end
+
+        def validate_file_extension(filename)
+          if File.extname(filename) != ".json"
+            raise(
+              ShopifyCLI::Abort, ShopifyCLI::Context.message("#{L10N_ERROR_PREFIX}.invalid_file_extension", filename)
+            )
+          end
+        end
+
+        def validate_file_locale_code(filename)
+          unless valid_locale_code?(basename_for_locale_filename(filename))
+            raise(
+              ShopifyCLI::Abort, ShopifyCLI::Context.message("#{L10N_ERROR_PREFIX}.invalid_locale_code", filename)
+            )
+          end
+        end
+
+        def validate_file_size(filename)
+          if File.size(filename) > L10N_FILE_SIZE_LIMIT
+            raise(
+              ShopifyCLI::Abort,
+              ShopifyCLI::Context.message(
+                "#{L10N_ERROR_PREFIX}.file_too_large",
+                filename,
+                CLI::Kit::Util.to_filesize(L10N_FILE_SIZE_LIMIT)
+              )
+            )
+          end
+        end
+
+        def validate_file_not_empty(filename)
+          if File.zero?(filename)
+            raise(ShopifyCLI::Abort, ShopifyCLI::Context.message("#{L10N_ERROR_PREFIX}.file_empty", filename))
+          end
+        end
+
+        def valid_locale_code?(locale_code)
+          LOCALE_CODE_FORMAT.match?(locale_code)
+        end
+
+        def basename_for_locale_filename(filename)
+          File.basename(File.basename(filename, ".json"), ".default")
+        end
+
+        def raise_invalid_encoding_error(filename)
+          raise(
+            ShopifyCLI::Abort,
+            ShopifyCLI::Context.message("#{L10N_ERROR_PREFIX}.invalid_file_encoding", filename)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Extension
+  module Models
+    module SpecificationHandlers
+      class Default
+        attr_reader :specification
+
+        def initialize(specification)
+          @specification = specification
+        end
+
+        def identifier
+          specification.identifier.to_s.upcase
+        end
+
+        def graphql_identifier
+          specification.graphql_identifier.to_s.upcase
+        end
+
+        def name
+          message("name") || specification.name
+        end
+
+        def tagline
+          message("tagline") || ""
+        end
+
+        def config(context)
+          argo.config(context)
+        end
+
+        def create(directory_name, context, **_args)
+          argo.create(directory_name, identifier, context)
+        end
+
+        def extension_context(_context)
+          nil
+        end
+
+        def valid_extension_contexts
+          []
+        end
+
+        def choose_port?(context)
+          return true if supports_development_server?
+          argo_runtime(context).supports?(:port)
+        end
+
+        def establish_tunnel?(context)
+          return true if supports_development_server?
+          argo_runtime(context).supports?(:public_url)
+        end
+
+        def serve(**options)
+          context = options[:context]
+          port = options[:port]
+          tunnel_url = options[:tunnel_url]
+          resource_url = options[:resource_url]
+
+          Features::ArgoServe.new(
+            specification_handler: self,
+            argo_runtime: argo_runtime(context),
+            context: context,
+            port: port,
+            tunnel_url: tunnel_url,
+            resource_url: resource_url
+          ).call
+        end
+
+        def renderer_package(context)
+          argo.renderer_package(context)
+        end
+
+        def argo_runtime(context)
+          return if supports_development_server?
+
+          @argo_runtime ||= Features::ArgoRuntime.find(
+            cli_package: cli_package(context),
+            identifier: identifier
+          )
+        end
+
+        def cli_package(context)
+          cli_package_name = specification.features.argo&.cli_package_name
+          return unless cli_package_name
+
+          js_system = ShopifyCLI::JsSystem.new(ctx: context)
+          Tasks::FindNpmPackages.exactly_one_of(cli_package_name, js_system: js_system)
+            .unwrap { |_e| context.abort(context.message("errors.package_not_found", cli_package_name)) }
+        end
+
+        def message_for_extension(key, *params)
+          override_key = "overrides.#{key}"
+          key_parts = override_key.split(".").map(&:to_sym)
+          if (str = messages.dig(*key_parts))
+            str % params
+          else
+            ShopifyCLI::Context.message(key, *params)
+          end
+        end
+
+        def supplies_resource_url?
+          false
+        end
+
+        def build_resource_url(shop)
+          raise NotImplementedError
+        end
+
+        def server_config_path(base_dir = Dir.pwd)
+          File.join(base_dir, server_config_file)
+        end
+
+        def server_config_file
+          "extension.config.yml"
+        end
+
+        protected
+
+        def argo
+          Features::Argo.new(
+            git_template: specification.features.argo.git_template,
+            renderer_package_name: specification.features.argo.renderer_package_name
+          )
+        end
+
+        private
+
+        def message(key, *params)
+          return unless messages.key?(key.to_sym)
+          messages[key.to_sym] % params
+        end
+
+        def messages
+          @messages ||= Messages::TYPES[identifier.downcase.to_sym] || {}
+        end
+
+        def supports_development_server?
+          Models::DevelopmentServerRequirements.supported?(identifier)
+        end
+      end
+    end
+  end
+end