shopify-cli 0.9.0

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

@@ -0,0 +1,32 @@
+module ShopifyCli
+  class PartnersAPI
+    class Organizations
+      class << self
+        def fetch_all(ctx)
+          resp = PartnersAPI.query(ctx, 'all_organizations')
+          resp['data']['organizations']['nodes'].map do |org|
+            org['stores'] = org['stores']['nodes']
+            org
+          end
+        end
+
+        def fetch(ctx, id:)
+          resp = PartnersAPI.query(ctx, 'find_organization', id: id)
+          org = resp['data']['organizations']['nodes'].first
+          return nil if org.nil?
+          org['stores'] = org['stores']['nodes']
+          org
+        end
+
+        def fetch_with_app(ctx)
+          resp = PartnersAPI.query(ctx, 'all_orgs_with_apps')
+          resp['data']['organizations']['nodes'].map do |org|
+            org['stores'] = org['stores']['nodes']
+            org['apps'] = org['apps']['nodes']
+            org
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify-cli/process_supervision.rb

@@ -0,0 +1,187 @@
+require 'fileutils'
+
+module ShopifyCli
+  ##
+  # ProcessSupervision wraps a running process spawned by `exec` and keeps track
+  # if its `pid` and keeps a log file for it as well
+  class ProcessSupervision
+    # is the directory where the pid and logfile are kept
+    RUN_DIR = File.join(ShopifyCli::CACHE_DIR, 'sv')
+
+    # a string or a symbol to identify this process by
+    attr_reader :identifier
+    # process ID for the running process
+    attr_reader :pid
+    # starttime of the process
+    attr_reader :time
+    # filepath to the pidfile for this process
+    attr_reader :pid_path
+    # filepath to the logfile for this process
+    attr_reader :log_path
+
+    class << self
+      ##
+      # Will find and create a new instance of ProcessSupervision for a running process
+      # if it is currently running. It will return nil if the process is not running.
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or a symbol that a process was started with
+      #
+      # #### Returns
+      #
+      # * `process` - ProcessSupervision instance if the process is running this
+      #   will be nil if the process is not running.
+      #
+      def for_ident(identifier)
+        pid, time = File.read(File.join(RUN_DIR, "#{identifier}.pid")).split(':')
+        new(identifier, pid: Integer(pid), time: time)
+      rescue Errno::ENOENT
+        nil
+      end
+
+      ##
+      # will fork and spawn a new process that is separate from the current process.
+      # This process will keep running beyond the command running so be careful!
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or symbol to identify the new process by.
+      # * `args` - a command to run, either a string or array of strings
+      #
+      # #### Returns
+      #
+      # * `process` - ProcessSupervision instance if the process is running, this
+      #   will be nil if the process did not start.
+      #
+      def start(identifier, args)
+        return for_ident(identifier) if running?(identifier)
+        fork do
+          pid_file = new(identifier, pid: Process.pid)
+          pid_file.write
+          STDOUT.reopen(pid_file.log_path, "w")
+          STDERR.reopen(pid_file.log_path, "w")
+          STDIN.reopen("/dev/null", "r")
+          Process.setsid
+          exec(*args)
+        end
+        sleep(0.1)
+        for_ident(identifier)
+      end
+
+      ##
+      # will attempt to shutdown a running process
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or symbol to identify the new process by.
+      #
+      # #### Returns
+      #
+      # * `stopped` - [true, false]
+      #
+      def stop(identifier)
+        process = for_ident(identifier)
+        return false unless process
+        process.stop
+      end
+
+      ##
+      # will help identify if your process is still running in the background.
+      #
+      # #### Parameters
+      #
+      # * `identifier` - a string or symbol to identify the new process by.
+      #
+      # #### Returns
+      #
+      # * `running` - [true, false]
+      #
+      def running?(identifier)
+        process = for_ident(identifier)
+        return false unless process
+        process.alive?
+      end
+    end
+
+    def initialize(identifier, pid:, time: Time.now.strftime('%s')) # :nodoc:
+      @identifier = identifier
+      @pid = pid
+      @time = time
+      @pid_path = File.join(RUN_DIR, "#{identifier}.pid")
+      @log_path = File.join(RUN_DIR, "#{identifier}.log")
+    end
+
+    ##
+    # will attempt to shutdown a running process
+    #
+    # #### Returns
+    #
+    # * `stopped` - [true, false]
+    #
+    def stop
+      unlink
+      kill_proc
+      true
+    rescue
+      false
+    end
+
+    ##
+    # will help identify if your process is still running in the background.
+    #
+    # #### Returns
+    #
+    # * `alive` - [true, false]
+    #
+    def alive?
+      stat(pid)
+    end
+
+    ##
+    # persists the pidfile
+    #
+    def write
+      FileUtils.mkdir_p(File.dirname(pid_path))
+      File.write(pid_path, "#{pid}:#{time}")
+    end
+
+    private
+
+    def unlink
+      File.unlink(pid_path)
+      File.unlink(log_path)
+      nil
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def kill_proc
+      kill(-pid) # process group
+    rescue Errno::ESRCH
+      begin
+        kill(pid)
+      rescue Errno::ESRCH # The process group does not exist, try the pid itself
+        # Race condition, process died in the middle
+      end
+    end
+
+    def kill(id)
+      Process.kill('TERM', id)
+      50.times do
+        sleep 0.1
+        break unless stat(id)
+      end
+      Process.kill('KILL', id) if stat(id)
+    end
+
+    def stat(id)
+      Process.kill(0, id) # signal 0 checks if pid is alive
+      true
+    rescue Errno::EPERM
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+end

data/lib/shopify-cli/project.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+require 'shopify_cli'
+
+module ShopifyCli
+  ##
+  # ShopifyCli::Project captures the current project that the user is working on.
+  # This class can be used to fetch and save project environment as well as the
+  # project config `.shopify-cli.yml`.
+  #
+  class Project
+    include SmartProperties
+
+    class << self
+      ##
+      # will get an instance of the project that the user is currently operating
+      # on. This is used for access to project resources.
+      #
+      # #### Returns
+      #
+      # * `project` - a Project instance if the user is currently in the project.
+      #
+      # #### Raises
+      #
+      # * `ShopifyCli::Abort` - If the cli is not currently in a project directory
+      #   then this will be raised with a message implying that the user is not in
+      #   a project directory.
+      #
+      # #### Example
+      #
+      #   project = ShopifyCli::Project.current
+      #
+      def current
+        at(Dir.pwd)
+      end
+
+      ##
+      # will return true if the command line is currently within a project
+      #
+      # #### Returns
+      #
+      # * `has_current?` - boolean, true if there is a current project
+      #
+      def has_current?
+        !directory(Dir.pwd).nil?
+      end
+
+      ##
+      # will fetch the project type of the current project. This is mostly used
+      # for internal project type loading, you should not normally need this.
+      #
+      # #### Returns
+      #
+      # * `type` - a symbol of the name of the project type identifier. i.e. [rails, node]
+      #   This will be nil if the user is not in a current project.
+      #
+      # #### Example
+      #
+      #   type = ShopifyCli::Project.current_project_type
+      #
+      def current_project_type
+        return unless has_current?
+        current.config['project_type'].to_sym
+      end
+
+      ##
+      # writes out the `.shopify-cli.yml` file. You should use this when creating
+      # a project type so that the rest of your project type commands will load
+      # in this project, in the future.
+      #
+      # #### Parameters
+      #
+      # * `ctx` - the current running context of your command
+      # * `project_type` - a string or symbol of your project type name
+      # * `organization_id` - the id of the partner organization that the app is owned by. Used for metrics
+      # * `identifiers` - an optional hash of other app identifiers
+      #
+      # #### Example
+      #
+      #   type = ShopifyCli::Project.current_project_type
+      #
+      def write(ctx, project_type:, organization_id:, **identifiers)
+        require 'yaml' # takes 20ms, so deferred as late as possible.
+        content = Hash[{ project_type: project_type, organization_id: organization_id.to_i }
+          .merge(identifiers)
+          .collect { |k, v| [k.to_s, v] }]
+
+        ctx.write('.shopify-cli.yml', YAML.dump(content))
+      end
+
+      def project_name
+        File.basename(current.directory)
+      end
+
+      private
+
+      def directory(dir)
+        @dir ||= Hash.new { |h, k| h[k] = __directory(k) }
+        @dir[dir]
+      end
+
+      def at(dir)
+        proj_dir = directory(dir)
+        unless proj_dir
+          raise(ShopifyCli::Abort, Context.message('core.project.error.not_in_project'))
+        end
+        @at ||= Hash.new { |h, k| h[k] = new(directory: k) }
+        @at[proj_dir]
+      end
+
+      def __directory(curr)
+        loop do
+          return nil if curr == '/'
+          file = File.join(curr, '.shopify-cli.yml')
+          return curr if File.exist?(file)
+          curr = File.dirname(curr)
+        end
+      end
+    end
+
+    property :directory # :nodoc:
+
+    ##
+    # will read, parse and return the envfile for the project
+    #
+    # #### Returns
+    #
+    # * `env` - An instance of a ShopifyCli::Resources::EnvFile
+    #
+    # #### Example
+    #
+    #   ShopifyCli::Project.current.env
+    #
+    def env
+      @env ||= begin
+                 Resources::EnvFile.read(directory)
+               rescue Errno::ENOENT
+                 nil
+               end
+    end
+
+    ##
+    # will read, parse and return the .shopify-cli.yml for the project
+    #
+    # #### Returns
+    #
+    # * `config` - A hash of configuration
+    #
+    # #### Raises
+    #
+    # * `ShopifyCli::Abort` - If the yml is invalid or poorly formatted
+    # * `ShopifyCli::Abort` - If the yml file does not exist
+    #
+    # #### Example
+    #
+    #   ShopifyCli::Project.current.config
+    #
+    def config
+      @config ||= begin
+        config = load_yaml_file('.shopify-cli.yml')
+        unless config.is_a?(Hash)
+          raise ShopifyCli::Abort, Context.message('core.project.error.cli_yaml.not_hash')
+        end
+
+        # The app_type key was deprecated in favour of project_type, so replace it
+        if config.key?('app_type')
+          config['project_type'] = config['app_type']
+          config.delete('app_type')
+        end
+
+        config
+      end
+    end
+
+    private
+
+    def load_yaml_file(relative_path)
+      f = File.join(directory, relative_path)
+      require 'yaml' # takes 20ms, so deferred as late as possible.
+      begin
+        YAML.load_file(f)
+      rescue Psych::SyntaxError => e
+        raise(ShopifyCli::Abort, Context.message('core.project.error.cli_yaml.invalid', relative_path, e.message))
+      # rescue Errno::EACCES => e
+      # TODO
+      #   Dev::Helpers::EaccesHandler.diagnose_and_raise(f, e, mode: :read)
+      rescue Errno::ENOENT
+        raise ShopifyCli::Abort, Context.message('core.project.error.cli_yaml.not_found', f)
+      end
+    end
+  end
+end

data/lib/shopify-cli/project_type.rb

@@ -0,0 +1,83 @@
+module ShopifyCli
+  class ProjectType
+    class << self
+      attr_accessor :project_type,
+        :project_name,
+        :project_creator_command_class,
+        :project_load_shallow
+      attr_reader :hidden
+
+      def repository
+        @repository ||= []
+      end
+      alias_method :all_loaded, :repository
+
+      def inherited(klass)
+        repository << klass
+        klass.project_type = @current_type
+        klass.project_load_shallow = @shallow_load
+      end
+
+      def load_type(current_type, shallow = false)
+        filepath = File.join(ShopifyCli::ROOT, 'lib', 'project_types', current_type.to_s, 'cli.rb')
+        return unless File.exist?(filepath)
+        @shallow_load = shallow
+        @current_type = current_type
+        load(filepath)
+        @current_type = nil
+        @shallow_load = false
+        for_app_type(current_type)
+      end
+
+      def load_all
+        Dir.glob(File.join(ShopifyCli::ROOT, 'lib', 'project_types', '*', 'cli.rb')).map do |filepath|
+          load_type(filepath.split(File::Separator)[-2], true)
+        end
+      end
+
+      def for_app_type(type)
+        repository.find { |k| k.project_type.to_s == type.to_s }
+      end
+
+      def project_filepath(path)
+        File.join(ShopifyCli::PROJECT_TYPES_DIR, project_type.to_s, path)
+      end
+
+      def creator(name, command_const)
+        @project_name = name
+        @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 hidden_project_type
+        @hidden = true
+      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
+        Task::Registry.add(const_get(task), name)
+      end
+
+      def register_messages(messages)
+        # Make sure we don't attempt to register a file more than once as that will fail
+        @registered_message_files ||= {}
+        return if @registered_message_files.key?(@project_type)
+        @registered_message_files[@project_type] = true
+
+        Context.load_messages(messages)
+      end
+    end
+  end
+end