shopify-cli 1.14.0 → 2.0.0

data/lib/project_types/theme/commands/serve.rb

@@ -1,26 +1,16 @@
 # frozen_string_literal: true
-module Theme
-  module Commands
-    class Serve < ShopifyCli::Command
-      prerequisite_task :ensure_themekit_installed
+require "shopify-cli/theme/dev_server"
 
+module Theme
+  class Command
+    class Serve < ShopifyCli::SubCommand
       options do |parser, flags|
-        parser.on("--env=ENV") { |env| flags[:env] = env }
-        parser.on("--allow-live") { flags["allow-live"] = true }
-        parser.on("--notify=FILES") { |files| flags["notify"] = files }
+        parser.on("--port=PORT") { |port| flags[:port] = port.to_i }
       end
 
       def call(*)
-        if options.flags[:env]
-          env = options.flags[:env]
-          options.flags.delete(:env)
-        end
-
-        flags = Themekit.add_flags(options.flags)
-
-        CLI::UI::Frame.open(@ctx.message("theme.serve.serve")) do
-          Themekit.serve(@ctx, flags: flags, env: env)
-        end
+        flags = options.flags.dup
+        ShopifyCli::Theme::DevServer.start(@ctx, ".", **flags)
       end
 
       def self.help

data/lib/project_types/theme/forms/confirm_store.rb

@@ -0,0 +1,15 @@
+module Theme
+  module Forms
+    class ConfirmStore < ShopifyCli::Form
+      flag_arguments :title, :force
+
+      def ask
+        @confirmed = force || CLI::UI::Prompt.confirm(title, default: false)
+      end
+
+      def confirmed?
+        @confirmed
+      end
+    end
+  end
+end

data/lib/project_types/theme/forms/select.rb

@@ -0,0 +1,59 @@
+module Theme
+  module Forms
+    class Select < ShopifyCli::Form
+      attr_accessor :theme
+      flag_arguments :root, :title, :exclude_roles, :include_foreign_developments
+
+      def ask
+        self.theme = CLI::UI::Prompt.ask(title, allow_empty: false) do |handler|
+          themes.each do |theme|
+            next if exclude_roles&.include?(theme.role)
+            next if !include_foreign_developments && theme.foreign_development?
+            handler.option("#{theme.name} #{theme_tags(theme)}") { theme }
+          end
+        end
+      end
+
+      private
+
+      def themes
+        @themes ||= ShopifyCli::Theme::Theme.all(@ctx, root: root)
+          .sort_by { |theme| theme_sort_order(theme) }
+      end
+
+      def theme_sort_order(theme)
+        case theme.role
+        when "live"
+          0
+        when "unpublished"
+          1
+        when "development"
+          2
+        else
+          3
+        end
+      end
+
+      def theme_tags(theme)
+        color = case theme.role
+        when "live"
+          "green"
+        when "unpublished"
+          "yellow"
+        when "development"
+          "blue"
+        else
+          "grey"
+        end
+
+        tags = ["{{#{color}:[#{theme.role}]}}"]
+
+        if theme.current_development?
+          tags << "{{cyan:[yours]}}}}"
+        end
+
+        tags.join(" ")
+      end
+    end
+  end
+end

data/lib/project_types/theme/messages/messages.rb

@@ -3,143 +3,147 @@ module Theme
   module Messages
     MESSAGES = {
       theme: {
-        connect: {
-          duplicate: "Duplicate directory, theme files weren't connected",
-          help: <<~HELP,
-            {{command:%s connect theme}}: Connects an existing theme in your store to Shopify App CLI. Downloads a copy of the theme files to your local development environment.
-              Usage: {{command:%s connect theme}}
-              Options:
-                {{command:--store=MYSHOPIFYDOMAIN}} Store URL. Must be an existing store with private apps enabled.
-                {{command:--password=PASSWORD}} Private app password. App must have Read and Write Theme access.
-                {{command:--themeid=THEMEID}} Theme ID. Must be an existing theme on your store.
-          HELP
-          inside_project: "You are inside an existing theme, theme files weren't connected",
-          connect: "Downloading theme files...",
-          failed: "Couldn't download theme files from store",
-          connected: "{{green:%s}} files were downloaded from {{underline:%s}} to {{green:%s}}",
-        },
-        create: {
-          creating_theme: "Creating theme %s",
-          duplicate_theme: "Duplicate theme",
-          failed: "Couldn't create the theme",
-          help: <<~HELP,
-            {{command:%s create theme}}: Creates a theme.
-              Usage: {{command:%s create theme}}
-              Options:
-                {{command:--store=MYSHOPIFYDOMAIN}} Store URL. Must be an existing store with private apps enabled.
-                {{command:--password=PASSWORD}} Private app password. App must have Read and Write Theme access.
-                {{command:--name=NAME}} Theme name. Any string.
-          HELP
-          info: {
-            created: "{{green:%s}} was created for {{underline:%s}} in {{green:%s}}",
-          },
-        },
-        deploy: {
-          abort: "Theme wasn't deployed",
-          confirmation: "This will change your live theme. Do you wish to proceed?",
+        help: <<~HELP,
+          Suite of commands for developing Shopify themes. See {{command:%1$s theme <command> --help}} for usage of each command.
+            Usage: {{command:%1$s theme [ %2$s ]}}
+        HELP
+
+        publish: {
+          confirmation: "This will change your live theme. Do you want to continue?",
           deploying: "Deploying theme",
           error: "Theme couldn't be deployed",
           help: <<~HELP,
-            {{command:%s deploy}}: Uploads your local theme files to Shopify, then sets your theme as the live theme.
-              Usage: {{command:%s deploy}}
+            {{command:%s theme publish}}: Set a remote theme as the live theme.
+              Usage: {{command:%s theme publish [ THEME_ID ]}}
+
+              Options:
+                {{command:-f, --force}}         Skip confirmation.
+
+              Run without arguments to select theme from a list.
           HELP
-          info: {
-            deployed: "Theme was updated and set as the live theme",
-            pushed: "All theme files were updated",
-          },
-          push_fail: "Theme files couldn't be updated",
+          done: "Your theme is now live at %s",
+          not_found: "Theme #%s does not exist",
+          select: "Select theme to push to",
+          confirm: "Are you sure you want to make %s the new live theme on %s?",
         },
         forms: {
           ask_password: "Password:",
           ask_store: "Store domain:",
-          create: {
-            ask_title: "Title:",
-            private_app: <<~APP,
-              To create a new theme, Shopify App CLI needs to connect with a private app installed on your store. Visit {{underline:%s/admin/apps/private}} to create a new API key and password, or retrieve an existing password.
-              If you create a new private app, ensure that it has Read and Write Theme access.
-            APP
-          },
-          connect: {
-            private_app: <<~APP,
-              To fetch your existing themes, Shopify App CLI needs to connect with your store. Visit {{underline:%s/admin/apps/private}} to create a new API key and password, or retrieve an existing password.
-              If you create a new private app, ensure that it has Read and Write Theme access.
-            APP
-          },
           errors: "%s can't be blank",
         },
-        generate: {
-          env: {
-            ask_password: "Password",
-            ask_password_default: "Password (defaults to {{green:%s}})",
-            ask_store: "Store",
-            ask_store_default: "Store (defaults to {{green:%s}})",
-            ask_theme: "Select theme",
-            help: <<~HELP,
-              Create or update configuration file in the current directory.
-                Usage: {{command:%s generate env}}
-                Options:
-                  {{command:--store=MYSHOPIFYDOMAIN}} Store URL. Must be an existing store with private apps enabled.
-                  {{command:--password=PASSWORD}} Private app password. App must have Read and Write Theme access.
-                  {{command:--themeid=THEMEID}} Theme ID. Must be an existing theme on your store.
-            HELP
-            no_themes: "Please create a new theme using %s create theme",
-          },
-          help: <<~HELP,
-            Generate code in your Theme. Currently supports generating new envs.
-              Usage: {{command:%s generate [ env ]}}
-          HELP
-        },
         push: {
           remove_abort: "Theme files weren't deleted",
-          remove_confirm: "This will delete the local and remote copies of the theme files. Do you wish to proceed?",
+          remove_confirm:
+            "This will delete the local and remote copies of the theme files, which " \
+            "can't be undone. Do you want to continue?",
           error: {
             push_error: "Theme files couldn't be pushed to Shopify",
             remove_error: "Theme files couldn't be removed from Shopify",
           },
           help: <<~HELP,
-            {{command:%s push}}: Uploads your local theme files to Shopify, overwriting the remote versions. If you specify filenames, separated by a space, only those files will be replaced. Otherwise, the whole theme will be replaced.
-              Usage: {{command:%s push}}
+            {{command:%s theme push}}: Uploads your local theme files to the connected store, overwriting the remote version if specified.
+
+              Usage: {{command:%s theme push [ ROOT ]}}
+
               Options:
-                {{command:--remove}} Deletes both the local and the remote copies of the specified files. At least one filename must be specified.
-                {{command:--allow-live}} Allows Shopify App CLI to replace files on the store's live production theme.
-                {{command:--nodelete}} Runs the push command without deleting remote files from Shopify.
+                {{command:-i, --themeid=THEMEID}} Theme ID. Must be an existing theme on your store.
+                {{command:-d, --development}}     Push to your remote development theme, and create it if needed.
+                {{command:-u, --unpublished}}     Create a new unpublished theme and push to it.
+                {{command:-n, --nodelete}}        Runs the push command without deleting remote files from Shopify.
+                {{command:-j, --json}}            Output JSON instead of a UI.
+                {{command:-a, --allow-live}}      Allow push to a live theme.
+                {{command:-p, --publish}}         Publish as the live theme after uploading.
+
+              Run without options to select theme from a list.
           HELP
           info: {
-            push: "Theme files were pushed from {{green:%s}} to Shopify",
-            remove: "Theme files were deleted from {{green:%s}} and Shopify",
+            pushing: "Pushing theme files to %s (#%s) on %s",
           },
           push: "Pushing theme files to Shopify",
-          remove: "Deleting theme files",
+          select: "Select theme to push to",
+          live: "Are you sure you want to push to your live theme?",
+          theme_not_found: "Theme #%s doesn't exist",
+          done: <<~DONE,
+            {{green:Your theme was pushed successfully}}
+
+              {{info:View your theme:}}
+              {{underline:%s}}
+
+              {{info:Customize this theme in the Online Store Editor:}}
+              {{underline:%s}}
+          DONE
+          name: "Theme name",
         },
         serve: {
           help: <<~HELP,
-            Sync your current changes, then view the active store in your default browser. Any theme edits will continue to update in real time. Also prints the active store's URL in your terminal.
-            Usage: {{command:%s serve}}
+            Uploads the current theme as a development theme to the connected store, then prints theme editor and preview URLs to your terminal. While running, changes will push to the store in real time.
+            Usage: {{command:%s theme serve}}
           HELP
           serve: "Viewing theme...",
           open_fail: "Couldn't open the theme",
         },
-        tasks: {
-          ensure_themekit_installed: {
-            auto_update: "Would you like to enable auto-updating?",
-            downloading: "Downloading Theme Kit %s",
-            errors: {
-              digest_fail: "Unable to verify download",
-              releases_fail: "Unable to fetch Theme Kit's list of releases",
-              update_fail: "Unable to update Theme Kit",
-              write_fail: "Unable to download Theme Kit",
-            },
-            installing_themekit: "Installing Theme Kit",
-            successful: "Theme Kit installed successfully",
-            updating_themekit: "Updating Theme Kit",
-            verifying: "Verifying download...",
-          },
+        check: {
+          help: <<~HELP,
+            Check your theme for errors, suggestions, and best practices.
+            Usage: {{command:%s check}}
+          HELP
         },
-        themekit: {
-          query_themes: {
-            bad_password: "Bad password",
-            not_connect: "Couldn't connect to given shop",
+        delete: {
+          help: <<~HELP,
+            {{command:%s theme delete}}: Delete remote themes from the connected store. This command can't be undone.
+
+            Usage: {{command:%s theme delete [ THEME_ID [ ... ] ]}}
+
+            Options:
+              {{command:-d, --development}}     Delete your development theme.
+              {{command:-a, --show-all}}        Include others development themes in theme list.
+              {{command:-f, --force}}           Skip confirmation.
+
+            Run without options to select the theme to delete from a list.
+          HELP
+          select: "Select theme to delete",
+          done: "%s theme(s) deleted",
+          not_found: "{{x}} Theme #%s does not exist",
+          live: "{{x}} Theme #%s is your live theme. You can't delete it.",
+          confirm: "Are you sure you want to delete %s on %s?",
+        },
+        package: {
+          help: <<~HELP,
+            {{command:%s theme package}}: Package your theme into a .zip file, ready to upload to the Online Store.
+
+            Usage: {{command:%s theme package [ ROOT ]}}
+          HELP
+          error: {
+            prereq_command_required: "%1$s is required for packaging a theme. Please install %1$s "\
+              "using the appropriate package manager for your system.",
+            missing_config: "Provide a config/settings_schema.json to package your theme",
+            missing_theme_name: "Provide a theme_info.theme_name configuration in config/settings_schema.json",
           },
+          done: "Theme packaged in %s",
+        },
+        language_server: {
+          help: <<~HELP,
+            {{command:%s theme language-server}}: Start a Language Server Protocol server.
+
+            Usage: {{command:%s theme language-server}}
+          HELP
+        },
+        pull: {
+          help: <<~HELP,
+            {{command:%s theme pull}}: Downloads your remote theme files locally.
+
+            Usage: {{command:%s theme pull [ ROOT ]}}
+
+            Options:
+              {{command:-i, --themeid=THEMEID}} The Theme ID. Must be an existing theme on your store.
+              {{command:-n, --nodelete}}        Runs the pull command without deleting local files.
+
+            Run without options to select theme from a list.
+          HELP
+          select: "Select a theme to pull from",
+          pulling: "Pulling theme files from %s (#%s) on %s",
+          done: "Theme pulled successfully",
+          not_found: "{{x}} Theme #%s doesn't exist",
         },
       },
     }.freeze

data/lib/project_types/theme/ui/sync_progress_bar.rb

@@ -0,0 +1,20 @@
+module Theme
+  module UI
+    class SyncProgressBar
+      def initialize(syncer)
+        @syncer = syncer
+      end
+
+      def progress(method, **args)
+        @syncer.delay_errors!
+        CLI::UI::Progress.progress do |bar|
+          @syncer.public_send(method, **args) do |left, total|
+            bar.tick(set_percent: 1 - left.to_f / total)
+          end
+          bar.tick(set_percent: 1)
+        end
+        @syncer.report_errors!
+      end
+    end
+  end
+end

data/lib/shopify-cli/admin_api.rb

@@ -38,9 +38,15 @@ module ShopifyCli
       #   ShopifyCli::AdminAPI.query(@ctx, 'all_organizations')
       #
       def query(ctx, query_name, shop:, api_version: nil, **variables)
-        authenticated_req(ctx, shop) do
+        CLI::Kit::Util.begin do
           api_client(ctx, api_version, shop).query(query_name, variables: variables)
+        end.retry_after(API::APIRequestUnauthorizedError, retries: 1) do
+          ShopifyCli::IdentityAuth.new(ctx: ctx).reauthenticate
         end
+      rescue API::APIRequestUnauthorizedError
+        ctx.abort(ctx.message("core.api.error.failed_auth"))
+      rescue API::APIRequestForbiddenError
+        ctx.abort(ctx.message("core.api.error.forbidden", ShopifyCli::TOOL_NAME))
       end
 
       ##
@@ -75,52 +81,47 @@ module ShopifyCli
       #                                     path: 'data.json',
       #                                     token: 'password')
       #
-      def rest_request(ctx, shop:, path:, body: nil, method: "GET", api_version: nil, token: nil)
-        ShopifyCli::DB.set(admin_access_token: token) unless token.nil?
-        url = URI::HTTPS.build(host: shop, path: "/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}")
-        resp = api_client(ctx, api_version, shop, path: path).request(url: url.to_s, body: body, method: method)
-        ShopifyCli::DB.set(admin_access_token: nil) unless token.nil?
-        resp
+      def rest_request(ctx, shop:, path:, query: nil, body: nil, method: "GET", api_version: nil, token: nil)
+        CLI::Kit::Util.begin do
+          ShopifyCli::DB.set(shopify_exchange_token: token) unless token.nil?
+          url = URI::HTTPS.build(
+            host: shop,
+            path: "/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}",
+            query: query,
+          )
+          resp = api_client(ctx, api_version, shop, path: path).request(url: url.to_s, body: body, method: method)
+          ShopifyCli::DB.set(shopify_exchange_token: nil) unless token.nil?
+          resp
+        end.retry_after(API::APIRequestUnauthorizedError) do
+          ShopifyCli::IdentityAuth.new(ctx: ctx).reauthenticate
+        end
       end
 
-      private
-
-      def authenticated_req(ctx, shop, &block)
-        CLI::Kit::Util
-          .begin(&block)
-          .retry_after(API::APIRequestUnauthorizedError, retries: 1) do
-            authenticate(ctx, shop)
-          end
-      rescue API::APIRequestUnauthorizedError
-        ctx.abort(ctx.message("core.api.error.failed_auth"))
+      def get_shop_or_abort(ctx)
+        ctx.abort(
+          ctx.message("core.populate.error.no_shop", ShopifyCli::TOOL_NAME)
+        ) unless ShopifyCli::DB.exists?(:shop)
+        ShopifyCli::DB.get(:shop)
       end
 
-      def authenticate(ctx, shop)
-        env = Project.current.env
-        ShopifyCli::OAuth.new(
-          ctx: ctx,
-          service: "admin",
-          client_id: env.api_key,
-          secret: env.secret,
-          scopes: env.scopes,
-          token_path: "/access_token",
-          options: { "grant_options[]" => "per user" },
-        ).authenticate("https://#{shop}/admin/oauth")
+      private
+
+      def authenticate(ctx, _shop)
+        ShopifyCli::IdentityAuth.new(ctx: ctx).authenticate
       end
 
       def api_client(ctx, api_version, shop, path: "graphql.json")
         new(
           ctx: ctx,
-          auth_header: "X-Shopify-Access-Token",
-          token: admin_access_token(ctx, shop),
+          token: access_token(ctx, shop),
           url: "https://#{shop}/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}",
         )
       end
 
-      def admin_access_token(ctx, shop)
-        ShopifyCli::DB.get(:admin_access_token) do
+      def access_token(ctx, shop)
+        ShopifyCli::DB.get(:shopify_exchange_token) do
           authenticate(ctx, shop)
-          ShopifyCli::DB.get(:admin_access_token)
+          ShopifyCli::DB.get(:shopify_exchange_token)
         end
       end
 
@@ -128,14 +129,28 @@ module ShopifyCli
         return api_version unless api_version.nil?
         client = new(
           ctx: ctx,
-          auth_header: "X-Shopify-Access-Token",
-          token: admin_access_token(ctx, shop),
+          token: access_token(ctx, shop),
           url: "https://#{shop}/admin/api/unstable/graphql.json",
         )
-        versions = client.query("api_versions")["data"]["publicApiVersions"]
-        latest = versions.find { |version| version["displayName"].include?("Latest") }
-        latest["handle"]
+        CLI::Kit::Util.begin do
+          versions = client.query("api_versions")["data"]["publicApiVersions"]
+          latest = versions.find { |version| version["displayName"].include?("Latest") }
+          latest["handle"]
+        end.retry_after(API::APIRequestUnauthorizedError, retries: 1) do
+          ShopifyCli::IdentityAuth.new(ctx: ctx).reauthenticate
+        end
+      rescue API::APIRequestUnauthorizedError
+        ctx.abort(ctx.message("core.api.error.failed_auth"))
+      rescue API::APIRequestForbiddenError
+        ctx.abort(ctx.message("core.api.error.forbidden", ShopifyCli::TOOL_NAME))
       end
     end
+
+    def auth_headers(token)
+      {
+        Authorization: "Bearer #{token}",
+        "X-Shopify-Access-Token" => token, # TODO: Remove when we no longer need private apps
+      }
+    end
   end
 end