@shopify/cli-kit 3.39.0 → 3.40.1

package/assets/cli-ruby/lib/shopify_cli/result.rb

@@ -0,0 +1,448 @@
+module ShopifyCLI
+  ##
+  # This module defines two containers for wrapping the result of an action. One
+  # for signifying the successful execution of an action and one for signifying
+  # a failure. Both containers implement the same API, which has been designed
+  # to simplify transforming a result through a series of steps and centralize
+  # the error handling in one place. The implementation is heavily inspired by a
+  # concept known as result monads in other languages. Consider the following
+  # example that uses lambda expressions as stand-ins for more complex method
+  # objects:
+  #
+  #   require 'open-uri'
+  #   Todo = Struct.new(:title, :completed)
+  #
+  #   fetch_data = ->(url) { open(url) }
+  #   parse_data = ->(json) { JSON.parse(json) }
+  #   build_todo = ->(attrs) do
+  #     Todo.new(attrs.fetch(:title), attrs.fetch(:completed))
+  #   end
+  #
+  #   Result.wrap(&fetch_data)
+  #     .call("https://jsonplaceholder.typicode.com/todos/1")
+  #     .then(&parse_data)
+  #     .then(&build_todo)
+  #     .map(&:title)
+  #     .unwrap(nil) # => String | nil
+  #
+  # If everything goes well, this code returns the title of the to do that is
+  # being fetched from `https://jsonplaceholder.typicode.com/todos/1`. However,
+  # there are several possible failure scenarios:
+  #
+  # * fetching the data could fail due to a network error,
+  # * the data returned from the server might not be valid JSON, or
+  # * the data is valid but does not have the right shape.
+  #
+  # If any of these scenarios arises, all subsequent `then` and `map` blocks are
+  # skipped until the result is either unwrapped or we manually recover from the
+  # failure by specifying a `rescue` clause:
+  #
+  #   Result.wrap { raise "Boom!" }
+  #     .rescue { |e| e.message.upcase }
+  #     .unwrap(nil) # => "BOOM!"
+  #
+  # In the event of a failure that hasn't been rescued from,
+  # `unwrap` returns the fallback value specified by the caller:
+  #
+  #   Result.wrap { raise "Boom!" }.unwrap(nil) # => nil
+  #   Result.wrap { raise "Boom!" }.unwrap { |e| e.message } # => "Boom!"
+  #
+  module Result
+    class Error < RuntimeError; end
+    class UnexpectedSuccess < Error; end
+    class UnexpectedFailure < Error; end
+
+    ##
+    # Implements a container for wrapping a success value. The main purpose of
+    # the container is to support further transformations of the result and
+    # centralize error handling should any of the subsequent transformations
+    # fail:
+    #
+    #   result = Result
+    #     .new("{}")
+    #     .then { |json| JSON.parse(json) }
+    #     .tap do |result|
+    #       result.success? # => true
+    #       result.value # => {}
+    #     .then { |data| data.fetch(:firstname) }
+    #     .tap do |result|
+    #       result.failure? # => true
+    #       result.error # => KeyError
+    #     end
+    #
+    # `Success` implements two transformation functions: `then` and `map`. The
+    # former makes no assumption regarding the return value of the
+    # transformation. The latter on the other hand expects the transformation to
+    # be successful. If this assumption is violated, program execution is
+    # interrupted and an error is raised. As the purpose of result objects is to
+    # guard against exactly that. This is generally a flaw and requires the code
+    # to either be hardened or to substitute the call to `map` with a call to
+    # `then`. `map` should only be used for transformations that cannot fail and
+    # when the caller wants to state exactly that fact.
+    #
+    class Success
+      attr_reader :value
+
+      ##
+      # initializes a new `Success` from an arbitrary value.
+      def initialize(value)
+        @value = value
+      end
+
+      ##
+      # always returns true to indicate that this result represents a success.
+      #
+      def success?
+        true
+      end
+
+      ##
+      # always returns false to indicate that this result represents a success.
+      #
+      def failure?
+        false
+      end
+
+      ##
+      # raises an `UnexpectedSuccess` as a `Success` does not carry an error
+      # value.
+      #
+      def error
+        raise UnexpectedSuccess
+      end
+
+      ##
+      # returns a new `Success` wrapping the result of the given block. The
+      # block is called with the current value. If the block raises an exception
+      # or returns a `Failure`, an exception is raised. `map` assumes any
+      # transformation to succeed. Transformations that are expected to fail under
+      # certain conditions should only be transformed using `then`:
+      #
+      #   Success
+      #     .new(nil)
+      #     .map { |n| n + 1 } # => raises NoMethodError
+      #
+      # Therefore, map should only be used here if the previous success value is
+      # guaranteed to be a number or if the block handles nil cases properly:
+      #
+      #   Success
+      #     .new(nil)
+      #     .map { |n| (n || 0) + 1 }
+      #     .value # => 1
+      #
+      def map(&block)
+        self.then(&block).tap do |result|
+          return result if result.success?
+
+          result.unwrap { |error| error }.tap do |error|
+            case error
+            when Exception
+              raise error
+            else
+              raise UnexpectedFailure, error
+            end
+          end
+        end
+      end
+
+      ##
+      # returns a new result by wrapping the return value of the block. The
+      # block is invoked with the current success value. The result can either
+      # be a `Success` or a `Failure`. The former is the default. The latter
+      # occurs when executing the block either
+      #
+      # - raised an exception,
+      # - returned an instance of a subclass of `Exception`, or
+      # - returned a `Failure`.
+      #
+      # The example below illustrates this behavior:
+      #
+      #   result = Success
+      #     .new(1)
+      #     .then { |n| n + 1 }
+      #     .tap do |result|
+      #       result.success? # => true
+      #       result.value # => 2
+      #     end
+      #
+      #   result.then { |n| n / 0 }.error # => ZeroDivisionError
+      #   result.then { RuntimeError.new }.error # => RuntimeError
+      #   result.then { Failure.new("Boom!") }.error # => "Boom!"
+      #
+      def then(&block)
+        Result.wrap(&block).call(@value)
+      end
+
+      ##
+      # is a no-op and simply returns itself. Only a `Failure` can be
+      # transformed using `rescue`.
+      #
+      def rescue
+        self
+      end
+
+      ##
+      # returns the value this success represents
+      #
+      def unwrap!
+        value
+      end
+
+      ##
+      # returns the success value and ignores the fallback value that was either
+      # provided as a method argument or by passing a block. However, the caller
+      # is still required to specify a fallback value to ensure that in the
+      # event of a `Failure` program execution can continue in a controlled
+      # manner:
+      #
+      #    Success.new(1).unwrap(0) => 1
+      #
+      def unwrap(*args, &block)
+        raise ArgumentError, "expected either a fallback value or a block" unless (args.length == 1) ^ block
+        @value
+      end
+    end
+
+    ##
+    # Implements a container for wrapping an error value. In many cases, the
+    # error value is going to be an exception but other values are fully
+    # supported:
+    #
+    #   Failure
+    #     .new(RuntimeError.new("Something went wrong"))
+    #     .error # => RuntimeError.new
+    #
+    #   Failure
+    #     .new("Something went wrong")
+    #     .error # => "Something went wrong"
+    #
+    # `Failure` does not support transformations with `then` and `map`. When any
+    # of these two methods is invoked on a `Failure`, the `Failure` itself is
+    # returned unless it is rescued from or unwrapped. This enables the caller to
+    # build optimistic transformation chains and defer error handling:
+    #
+    #   Failure
+    #     .new(nil)
+    #     .then { |json| JSON.parse(json) }                      # Ignored
+    #     .then(&:with_indifferent_access)                       # Ignored
+    #     .then { |data| data.values_at(:firstname, :lastname) } # Ignored
+    #     .unwrap(Person.new("John", "Doe"))                     # => Person
+    #
+    # Alternatively, we could rescue from the error and then proceed with the
+    # remaining transformations:
+    #
+    #   Person = Struct.new(:firstname, :lastname)
+    #   Failure
+    #     .new(nil)
+    #     .then { |json| JSON.parse(json) }                      # Ignored
+    #     .then(&:with_indifferent_access)                       # Ignored
+    #     .rescue { {firstname: "John", lastname: "Doe" }}
+    #     .then { |data| data.values_at(:firstname, :lastname) } # Executed
+    #     .then { |members| Person.new(*members) }               # Executed
+    #     .unwrap(nil)                                           # => Person
+    #
+    class Failure
+      attr_reader :error
+
+      ##
+      # initializes a new `Failure` from an arbitrary value. In many cases, this
+      # value is going to be an instance of a subclass of `Exception` but any
+      # type is supported.
+      #
+      def initialize(error)
+        @error = error
+      end
+
+      ##
+      # always returns `false` to indicate that this result represents a failure.
+      #
+      def success?
+        false
+      end
+
+      ##
+      # Always returns `true` to indicate that this result represents a failure.
+      #
+      def failure?
+        true
+      end
+
+      ##
+      # raises an `ShopifyCLI::Result::UnexpectedError` as a
+      # `ShopifyCLI::Result::Failure` does not carry a success value.
+      #
+      def value
+        raise UnexpectedFailure
+      end
+
+      ##
+      # is a no-op and simply returns itself. This is essential to skip
+      # transformation steps in a chain once an error has occurred.
+      #
+      def map
+        self
+      end
+
+      ##
+      # is a no-op and simply returns itself. This is essential to skip
+      # transformation steps in a chain once an error has occurred.
+      #
+      def then
+        self
+      end
+
+      ##
+      # can be used to recover from a failure or produce a new failure with a
+      # different error.
+      #
+      #   Failure
+      #     .new("Something went wrong")
+      #     .rescue { |msg| [msg, "but we fixed it!"].join(" "") }
+      #     .tap do |result|
+      #        result.success? # => true
+      #        result.value # => "Something went wrong but we fixed it!"
+      #     end
+      #
+      # `rescue` is opinionated when it comes to the return value of the block.
+      # If the return value is an `Exception` – either one that was raised or an
+      # instance of a subclass of `Exception` – a `Failure` is returned. Any
+      # other value results in a `Success` unless the value has been explicitly
+      # wrapped in a `Failure`:
+      #
+      #   Failure
+      #     .new(RuntimeError.new)
+      #     .rescue { "All good! "}
+      #     .success? # => true
+      #
+      #   Failure
+      #     .new(RuntimeError.new)
+      #     .rescue { Failure.new("Still broken!") }
+      #     .success? # => false
+      #
+      def rescue(&block)
+        Result.wrap(&block).call(@error)
+      end
+
+      ##
+      # returns the fallback value specified by the caller. The fallback value
+      # can be provided as a method argument or as a block. If a block is given,
+      # it receives the error as its first and only argument:
+      #
+      #   failure = Failure.new(RuntimeError.new("Something went wrong!"))
+      #
+      #   failure.unwrap(nil) # => nil
+      #   failure.unwrap { |e| e.message } # => "Something went wrong!"
+      #
+      # #### Parameters
+      #
+      # * `*args` should be an `Array` with zero or one element
+      # * `&block`  should be a Proc that takes zero or one argument
+      #
+      # #### Raises
+      #
+      # * `ArgumentError` if both a fallback argument and a block is provided
+      #
+      def unwrap(*args, &block)
+        raise ArgumentError, "expected either a fallback value or a block" unless (args.length == 1) ^ block
+        block ? block.call(@error) : args.pop
+      end
+
+      ##
+      # raises the error this failure represents
+      #
+      def unwrap!
+        raise error
+      end
+    end
+
+    ##
+    # wraps the given value into a `ShopifyCLI::Result::Success` container
+    #
+    # #### Parameters
+    #
+    # * `value` a value of arbitrary type
+    #
+    def self.success(value)
+      Result::Success.new(value)
+    end
+
+    ##
+    # wraps the given value into a `ShopifyCLI::Result::Failure` container
+    #
+    # #### Parameters
+    #
+    # * `error` a value of arbitrary type
+    #
+    def self.failure(error)
+      Result::Failure.new(error)
+    end
+
+    class << self
+      ##
+      # takes either a value or a block and chooses the appropriate result
+      # container based on the type of the value or the type of the block's return
+      # value. If the type is an exception, it is wrapped in a
+      # `ShopifyCli::Result::Failure` and otherwise in a
+      # `ShopifyCli::Result::Success`. If a block was provided instead of value, a
+      # `Proc` is returned and the result wrapping doesn't occur until the block
+      # is invoked.
+      #
+      # #### Parameters
+      #
+      # * `*args` should be an `Array` with zero or one element
+      # * `&block` should be a `Proc` that takes zero or one argument
+      #
+      # #### Returns
+      #
+      # Returns either a `Result::Success`, `Result::Failure` or a `Proc` that
+      # produces one of the former when invoked.
+      #
+      # #### Examples
+      #
+      #   Result.wrap(1) # => ShopifyCli::Result::Success
+      #   Result.wrap(RuntimeError.new) # => ShopifyCli::Result::Failure
+      #
+      #   Result.wrap { 1 } # => Proc
+      #   Result.wrap { 1 }.call # => ShopifyCli::Result::Success
+      #   Result.wrap { raise }.call # => ShopifyCli::Result::Failure
+      #
+      #   Result.wrap { |s| s.upcase }.call("hello").tap do |result|
+      #     result # => Result::Success
+      #     result.value # => "HELLO"
+      #   end
+      #
+      ruby2_keywords def wrap(*values, &block)
+        raise ArgumentError, "expected either a value or a block" unless (values.length == 1) ^ block
+
+        if values.length == 1
+          values.pop.yield_self do |value|
+            case value
+            when Result::Success, Result::Failure
+              value
+            when NilClass, Exception
+              Result.failure(value)
+            else
+              Result.success(value)
+            end
+          end
+        else
+          ->(*args) do
+            begin
+              wrap(block.call(*args))
+            rescue Exception => error # rubocop:disable Lint/RescueException
+              wrap(error)
+            end
+          end.ruby2_keywords
+        end
+      end
+
+      ##
+      # Wraps the given block and invokes it with the passed arguments.
+      #
+      ruby2_keywords def call(*args, &block)
+        raise ArgumentError, "expected a block" unless block
+        wrap(&block).call(*args)
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/sed.rb

@@ -0,0 +1,19 @@
+module ShopifyCLI
+  class Sed
+    class SedError < StandardError; end
+
+    def replace_inline(filename, pattern, output)
+      command =
+        case CLI::Kit::System.os
+        when :mac
+          "sed -i ''"
+        when :linux
+          "sed -i"
+        else
+          raise "Unrecognized system!"
+        end
+      success = system("#{command} 's/#{pattern}/#{output}/' #{filename}")
+      raise SedError unless success
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/connect_service.rb

@@ -0,0 +1,25 @@
+module ShopifyCLI
+  module Services
+    module App
+      class ConnectService < BaseService
+        attr_reader :app_type, :project, :context
+
+        def initialize(app_type:, project:, context:)
+          @app_type = app_type
+          @project = project
+          @context = context
+          super()
+        end
+
+        def call
+          unless project&.env.nil?
+            context.puts(context.message("core.app.connect.production_warning"))
+          end
+
+          app = ShopifyCLI::Connect.new(context).default_connect(app_type.to_s)
+          context.done(context.message("core.app.connect.connected", app))
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/create/node_service.rb

@@ -0,0 +1,143 @@
+require "semantic/semantic"
+
+module ShopifyCLI
+  module Services
+    module App
+      module Create
+        class NodeService < BaseService
+          attr_reader :context, :name, :organization_id, :store_domain, :type, :verbose
+
+          def initialize(name:, organization_id:, store_domain:, type:, verbose:, context:)
+            @name = name
+            @organization_id = organization_id
+            @store_domain = store_domain
+            @type = type
+            @verbose = verbose
+            @context = context
+            super()
+          end
+
+          def call
+            form = form_data({
+              name: name,
+              organization_id: organization_id,
+              shop_domain: store_domain,
+              type: type,
+              verbose: verbose,
+            })
+
+            raise ShopifyCLI::AbortSilent if form.nil?
+
+            check_node
+            check_npm
+            build(form.name)
+
+            ShopifyCLI::Project.write(
+              context,
+              project_type: "node",
+              organization_id: form.organization_id,
+            )
+
+            api_client = if ShopifyCLI::Environment.acceptance_test?
+              {
+                "apiKey" => "public_api_key",
+                "apiSecretKeys" => [
+                  {
+                    "secret" => "api_secret_key",
+                  },
+                ],
+              }
+            else
+              ShopifyCLI::Tasks::CreateApiClient.call(
+                context,
+                org_id: form.organization_id,
+                title: form.name,
+                type: form.type,
+              )
+            end
+
+            ShopifyCLI::Resources::EnvFile.new(
+              api_key: api_client["apiKey"],
+              secret: api_client["apiSecretKeys"].first["secret"],
+              shop: form.shop_domain,
+              scopes: "write_products,write_customers,write_draft_orders",
+            ).write(context)
+
+            partners_url = ShopifyCLI::PartnersAPI.partners_url_for(form.organization_id, api_client["id"])
+
+            context.puts(context.message("apps.create.info.created", form.name, partners_url))
+            context.puts(context.message("apps.create.info.serve", form.name, ShopifyCLI::TOOL_NAME))
+            unless ShopifyCLI::Shopifolk.acting_as_shopify_organization?
+              context.puts(context.message("apps.create.info.install", partners_url, form.name))
+            end
+          end
+
+          private
+
+          def form_data(form_options)
+            if ShopifyCLI::Environment.acceptance_test?
+              Struct.new(:name, :organization_id, :type, :shop_domain, keyword_init: true).new(
+                name: form_options[:name],
+                organization_id: form_options[:organization_id] || "123",
+                shop_domain: form_options[:shop_domain] || "test.shopify.io",
+                type: form_options[:type] || "public",
+              )
+            else
+              Node::Forms::Create.ask(context, [], form_options)
+            end
+          end
+
+          def check_node
+            version = ShopifyCLI::Environment.node_version(context: context)
+            context.done(context.message("core.app.create.node.node_version", version))
+          end
+
+          def check_npm
+            version = ShopifyCLI::Environment.npm_version(context: context)
+            context.done(context.message("core.app.create.node.npm_version", version))
+          end
+
+          def set_npm_config
+            # check available npmrc (either user or system) for production registry
+            registry, _ = context.capture2("npm config get @shopify:registry")
+            return if registry.include?("https://registry.yarnpkg.com")
+
+            # available npmrc doesn't have production registry =>
+            # set a project-based .npmrc
+            context.system(
+              "npm",
+              "--userconfig",
+              "./.npmrc",
+              "config",
+              "set",
+              "@shopify:registry",
+              "https://registry.yarnpkg.com",
+              chdir: context.root
+            )
+          end
+
+          def build(name)
+            ShopifyCLI::Git.clone("https://github.com/Shopify/shopify-app-template-node.git#cli_two", name)
+
+            context.root = File.join(context.root, name)
+
+            set_npm_config
+            ShopifyCLI::JsDeps.install(context, verbose)
+
+            begin
+              context.rm_r(".git")
+              context.rm_r(".github")
+              context.rm(File.join("server", "handlers", "client.js"))
+              context.rename(
+                File.join("server", "handlers", "client.cli.js"),
+                File.join("server", "handlers", "client.js")
+              )
+            rescue Errno::ENOENT => e
+              context.debug(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end