@shopify/cli-kit 3.39.0 → 3.40.1

package/assets/cli-ruby/lib/shopify_cli/admin_api/populate_resource_command.rb

@@ -0,0 +1,166 @@
+require "shopify_cli"
+require "optparse"
+
+module ShopifyCLI
+  class AdminAPI
+    class PopulateResourceCommand < ShopifyCLI::Command::SubCommand
+      DEFAULT_COUNT = 5
+
+      attr_reader :input
+
+      class << self
+        attr_accessor :input_type
+
+        # we override the call classmethod here because we parse options at runtime
+        def call(args, command_name, _parent_command)
+          cmd = new(@ctx)
+          cmd.call(args, command_name)
+        end
+
+        def help
+          cmd = new(@ctx)
+          output = cmd.display_parent_help + "\n"
+          output + cmd.display_parent_extended_help
+        end
+      end
+
+      def call(args, _)
+        @args = args
+        @input = Hash.new
+        @count = DEFAULT_COUNT
+        @help = false
+        @skip_shop_confirmation = false
+        input_options
+        resource_options.parse(@args)
+
+        if @help
+          output = display_parent_extended_help
+          output += "\n#{@ctx.message("core.populate.options.header", camel_case_resource_type)}\n"
+          output += resource_options.help
+          return @ctx.puts(output)
+        end
+
+        ShopifyCLI::Tasks::ConfirmStore.call(@ctx) unless @skip_shop_confirmation
+        @shop = AdminAPI.get_shop_or_abort(@ctx)
+        if @silent
+          spin_group = CLI::UI::SpinGroup.new
+          spin_group.add(@ctx.message("core.populate.populating", @count, camel_case_resource_type)) do |spinner|
+            populate
+            spinner.update_title(completion_message)
+          end
+          spin_group.wait
+        else
+          populate
+          @ctx.puts(completion_message)
+        end
+      end
+
+      def message
+        raise NotImplementedError
+      end
+
+      def defaults
+        raise NotImplementedError
+      end
+
+      def display_parent_help
+        parent_command_klass.respond_to?(:help) ? parent_command_klass.help : ""
+      end
+
+      def display_parent_extended_help
+        parent_command_klass.respond_to?(:extended_help) ? parent_command_klass.extended_help : ""
+      end
+
+      def resource_options
+        @resource_options ||= OptionParser.new do |opts|
+          opts.banner = ""
+          opts.on(
+            "-c #{DEFAULT_COUNT}",
+            "--count=#{DEFAULT_COUNT}",
+            @ctx.message("core.populate.options.count_help")
+          ) do |value|
+            @count = value.to_i
+          end
+
+          opts.on("-h", "--help", "print help") do |value|
+            @help = value
+          end
+
+          opts.on("--silent") { |v| @silent = v }
+
+          opts.on("--skip-shop-confirmation") { |v| @skip_shop_confirmation = v }
+        end
+      end
+
+      def populate
+        @count.times do
+          run_mutation(defaults.merge(@input))
+        end
+      end
+
+      def input_options
+        schema.type(self.class.input_type)["inputFields"].each do |field|
+          resource_options.on(
+            "--#{field["name"]}=#{field["defaultValue"]}",
+            field["description"]
+          ) do |value|
+            @input[field["name"]] = value
+          end
+        end
+      end
+
+      def schema
+        @schema ||= AdminAPI::Schema.get(@ctx)
+      end
+
+      def run_mutation(data)
+        kwargs = { input: data }
+        kwargs[:shop] = @shop
+        resp = AdminAPI.query(
+          @ctx, "create_#{snake_case_resource_type}", **kwargs
+        )
+        @ctx.abort(resp["errors"]) if resp["errors"]
+        @ctx.done(message(resp["data"])) unless @silent
+      end
+
+      def completion_message
+        plural = @count > 1 ? "s" : ""
+        @ctx.message(
+          "core.populate.completion_message",
+          @count,
+          "#{camel_case_resource_type}#{plural}",
+          @shop,
+          camel_case_resource_type,
+          admin_url,
+          snake_case_resource_type
+        )
+      end
+
+      def admin_url
+        "https://#{@shop}/admin/"
+      end
+
+      def price
+        format("%.2f", rand(1..10))
+      end
+
+      private
+
+      def camel_case_resource_type
+        @camel_case_resource_type ||= self.class.to_s.split("::").last
+      end
+
+      def snake_case_resource_type
+        @snake_case_resource_type ||= camel_case_resource_type.to_s
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr("-", "_")
+          .downcase
+      end
+
+      def parent_command_klass
+        @parent_command_klass ||= Module.const_get(self.class.to_s.split("::")[0..-2].join("::"))
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/admin_api/schema.rb

@@ -0,0 +1,35 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  class AdminAPI
+    class Schema < Hash
+      class << self
+        def get(ctx)
+          unless ShopifyCLI::DB.exists?(:shopify_admin_schema)
+            shop = AdminAPI.get_shop_or_abort(ctx)
+            schema = AdminAPI.query(ctx, "admin_introspection", shop: shop)
+            ShopifyCLI::DB.set(shopify_admin_schema: JSON.dump(schema))
+          end
+          # This is ruby magic for making a new hash with another hash.
+          # It wraps the JSON in our Schema Class to have the helper methods
+          # available
+          self[JSON.parse(ShopifyCLI::DB.get(:shopify_admin_schema))]
+        end
+      end
+
+      def type(name)
+        data = self["data"]
+        schema = data["__schema"]
+        schema["types"].find do |object|
+          object["name"] == name.to_s
+        end
+      end
+
+      def get_names_from_type(name)
+        type(name)["enumValues"].map do |object|
+          object["name"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  ##
+  # ShopifyCLI::AdminAPI wraps our graphql functionality with authentication so that
+  # these concerns are taken care of.
+  #
+  class AdminAPI < API
+    autoload :PopulateResourceCommand, "shopify_cli/admin_api/populate_resource_command"
+    autoload :Schema, "shopify_cli/admin_api/schema"
+
+    class << self
+      ##
+      # issues a graphql query or mutation to the Shopify Admin API. It loads a graphql
+      # query from a file so that you do not need to use large unwieldy query strings.
+      #
+      # #### Parameters
+      # - `ctx`: running context from your command
+      # - `query_name`: name of the query you want to use, loaded from the `lib/graphql` directory.
+      # - `api_version`: an api version string to specify version. If no version is supplied then unstable will be used
+      # - `shop`: shop domain string for which shop that you are calling the admin
+      #   API on. If not supplied, then it will be fetched from the `.env` file
+      # - `**variable`: a hash of variables to be supplied to the query ro mutation
+      #
+      # #### Raises
+      #
+      # * http 404 will raise a ShopifyCLI::API::APIRequestNotFoundError
+      # * http 400..499 will raise a ShopifyCLI::API::APIRequestClientError
+      # * http 500..599 will raise a ShopifyCLI::API::APIRequestServerError
+      # * All other codes will raise ShopifyCLI::API::APIRequestUnexpectedError
+      #
+      # #### Returns
+      #
+      # * `resp` - graphql response data hash. This can be a different shape for every query.
+      #
+      # #### Example
+      #
+      #   ShopifyCLI::AdminAPI.query(@ctx, 'all_organizations')
+      #
+      def query(ctx, query_name, shop:, api_version: nil, **variables)
+        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
+
+      ##
+      #
+      #
+      #
+      # #### Parameters
+      # - `ctx`: running context from your command
+      # - `shop`: shop domain string for shop whose admin you are calling
+      # - `path`: path string (excluding prefixes and API version) for specific JSON that you are requesting
+      #     ex. "data.json" instead of "/admin/api/unstable/data.json"
+      # - `body`: data string for corresponding REST request types
+      # - `method`: REST request string for the type of request; if nil, will perform GET request
+      # - `api_version`: API version string to specify version; if nil, latest will be used
+      # - `token`: shop password string for authentication to shop
+      #
+      # #### Raises
+      #
+      # * http 404 will raise a ShopifyCLI::API::APIRequestNotFoundError
+      # * http 400..499 will raise a ShopifyCLI::API::APIRequestClientError
+      # * http 500..599 will raise a ShopifyCLI::API::APIRequestServerError
+      # * All other codes will raise ShopifyCLI::API::APIRequestUnexpectedError
+      #
+      # #### Returns
+      #
+      # * `resp` - JSON response array
+      #
+      # #### Example
+      #
+      #   ShopifyCLI::AdminAPI.rest_request(@ctx,
+      #                                     shop: 'shop.myshopify.com',
+      #                                     path: 'data.json',
+      #                                     token: 'password')
+      #
+      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
+
+      def get_shop_or_abort(ctx)
+        env_store = Environment.store
+        return env_store unless env_store.nil?
+        ctx.abort(
+          ctx.message("core.populate.error.no_shop", ShopifyCLI::TOOL_NAME)
+        ) unless ShopifyCLI::DB.exists?(:shop)
+        ShopifyCLI::DB.get(:shop)
+      end
+
+      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,
+          token: access_token(ctx, shop),
+          url: "https://#{shop}/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}",
+        )
+      end
+
+      def access_token(ctx, shop)
+        env_token = Environment.admin_auth_token
+        env_token || ShopifyCLI::DB.get(:shopify_exchange_token) do
+          authenticate(ctx, shop)
+          ShopifyCLI::DB.get(:shopify_exchange_token)
+        end
+      end
+
+      def fetch_api_version(ctx, api_version, shop)
+        return api_version unless api_version.nil?
+        client = new(
+          ctx: ctx,
+          token: access_token(ctx, shop),
+          url: "https://#{shop}/admin/api/unstable/graphql.json",
+        )
+        CLI::Kit::Util.begin do
+          versions = client.query("api_versions")["data"]["publicApiVersions"]
+          # return the most recent supported version
+          versions
+            .select { |version| version["supported"] }
+            .map { |version| version["handle"] }
+            .sort
+            .reverse[0]
+        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,
+      }
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+require "shopify_cli"
+require "securerandom"
+
+module ShopifyCLI
+  class API
+    include SmartProperties
+
+    property! :ctx, accepts: ShopifyCLI::Context
+    property! :token, accepts: String
+    property :auth_header, accepts: String
+    property! :url, accepts: String
+
+    class APIRequestError < StandardError
+      attr_reader :response
+
+      def initialize(message = nil, response: nil)
+        super(message)
+        @response = response
+      end
+    end
+
+    class APIRequestNotFoundError < APIRequestError; end
+    class APIRequestClientError < APIRequestError; end
+    class APIRequestUnauthorizedError < APIRequestClientError; end
+    class APIRequestForbiddenError < APIRequestClientError; end
+    class APIRequestUnexpectedError < APIRequestError; end
+    class APIRequestRetriableError < APIRequestError; end
+    class APIRequestTimeoutError < APIRequestRetriableError; end
+    class APIRequestServerError < APIRequestRetriableError; end
+    class APIRequestThrottledError < APIRequestRetriableError; end
+
+    def self.gid_to_id(gid)
+      gid.split("/").last
+    end
+
+    def query(query_name, variables: {})
+      _, resp = request(
+        body: JSON.dump(query: load_query(query_name).tr("\n", ""), variables: variables),
+        url: url,
+      )
+      ctx.debug(resp)
+      resp
+    rescue API::APIRequestServerError, API::APIRequestUnexpectedError => e
+      ctx.puts(ctx.message("core.api.error.internal_server_error"))
+      ctx.debug(ctx.message("core.api.error.internal_server_error_debug", e.message))
+    end
+
+    def request(url:, body: nil, headers: {}, method: "POST")
+      CLI::Kit::Util.begin do
+        uri = URI.parse(url)
+        unless uri.is_a?(URI::HTTP)
+          ctx.abort(ctx.message("core.api.error.invalid_url", url))
+        end
+
+        # we delay this require so as to avoid a performance hit on starting the CLI
+        require "shopify_cli/http_request"
+        headers = default_headers.merge(headers)
+        ctx.debug("#{method} #{uri} with X-Request-Id: #{headers["X-Request-Id"]}")
+        response = if method == "POST"
+          HttpRequest.post(uri, body, headers)
+        elsif method == "PUT"
+          HttpRequest.put(uri, body, headers)
+        elsif method == "GET"
+          HttpRequest.get(uri, body, headers)
+        elsif method == "DELETE"
+          HttpRequest.delete(uri, body, headers)
+        end
+        case response.code.to_i
+        when 200..399
+          [response.code.to_i, JSON.parse(response.body), response]
+        when 401
+          raise APIRequestUnauthorizedError.new("#{response.code}\n#{response.body}", response: response)
+        when 403
+          raise APIRequestForbiddenError.new("#{response.code}\n#{response.body}", response: response)
+        when 404
+          raise APIRequestNotFoundError.new("#{response.code}\n#{response.body}", response: response)
+        when 429
+          raise APIRequestThrottledError.new("#{response.code}\n#{response.body}", response: response)
+        when 400..499
+          raise APIRequestClientError.new("#{response.code}\n#{response.body}", response: response)
+        when 500..599
+          raise APIRequestServerError.new("#{response.code}\n#{response.body}", response: response)
+        else
+          raise APIRequestUnexpectedError.new("#{response.code}\n#{response.body}", response: response)
+        end
+      rescue Errno::ETIMEDOUT, Timeout::Error
+        ctx.debug("timeout in #{method} #{uri} with X-Request-Id: #{headers["X-Request-Id"]}")
+        raise APIRequestTimeoutError, "Timeout"
+      end.retry_after(APIRequestRetriableError, retries: 3) do |e|
+        sleep(1) if e.is_a?(APIRequestThrottledError)
+      end
+    end
+
+    protected
+
+    def load_query(name)
+      project_type = ShopifyCLI::Project.current_project_type
+      project_file_path = File.join(
+        ShopifyCLI::ROOT, "lib", "project_types", project_type.to_s, "graphql", "#{name}.graphql"
+      )
+      if !project_type.nil? && File.exist?(project_file_path)
+        File.read(project_file_path)
+      else
+        File.read(File.join(ShopifyCLI::ROOT, "lib", "graphql", "#{name}.graphql"))
+      end
+    end
+
+    private
+
+    def default_headers
+      sha = ShopifyCLI.sha
+      user_agent = "Shopify CLI; v=#{ShopifyCLI::VERSION}"
+      sec_ch_ua = user_agent
+      sec_ch_ua += " sha=#{sha}" unless sha.nil?
+
+      {
+        "User-Agent" => user_agent,
+        "Sec-CH-UA" => sec_ch_ua,
+        "Sec-CH-UA-PLATFORM" => ctx.os.to_s,
+        "X-Request-Id" => SecureRandom.uuid,
+      }.tap do |headers|
+        headers["X-Shopify-Cli-Employee"] = "1" if Shopifolk.acting_as_shopify_organization?
+      end.merge(auth_headers(token))
+    end
+
+    def auth_headers(token)
+      raise NotImplementedError if auth_header.nil?
+      { auth_header => token }
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "json"
+
+module ShopifyCLI
+  class AppTypeDetector
+    Error = Class.new(StandardError)
+    MissingShopifyCLIYamlError = Class.new(Error)
+    TypeNotFoundError = Class.new(Error)
+    class InvalidTypeError < Error
+      attr_reader :project_type
+      def initialize(message, project_type:)
+        @project_type = project_type
+        super(message)
+      end
+    end
+
+    def self.detect(project_directory:)
+      require "yaml" # takes 20ms, so deferred as late as possible.
+
+      shopify_cli_yml_path = File.join(project_directory, Constants::Files::SHOPIFY_CLI_YML)
+      unless File.exist?(shopify_cli_yml_path)
+        raise MissingShopifyCLIYamlError,
+          "#{Constants::Files::SHOPIFY_CLI_YML} was not found in directory #{project_directory}"
+      end
+      shopify_cli = YAML.load_file(shopify_cli_yml_path)
+      case shopify_cli["project_type"]&.to_sym
+      when :node, :rails, :php
+        shopify_cli["project_type"].to_sym
+      when nil
+        raise TypeNotFoundError, "Couldn't detect the project type in directory: #{project_directory}"
+      else
+        raise InvalidTypeError.new("The project found '' is not supported",
+          project_type: shopify_cli["project_type"])
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/assets/post_auth_page/index.html.erb

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Shopify CLI</title>
+    <style><%= locals[:css] %></style>
+    <link rel="icon" href="data:image/svg+xml;charset=UTF-8,%3c?xml version='1.0' encoding='utf-8'?%3e%3c!-- Generator: Adobe Illustrator 23.0.2, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3e%3csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 109.5 124.5' style='enable-background:new 0 0 109.5 124.5;' xml:space='preserve'%3e%3cstyle type='text/css'%3e .st0%7bfill:%2395BF47;%7d .st1%7bfill:%235E8E3E;%7d .st2%7bfill:%23FFFFFF;%7d %3c/style%3e%3cg%3e%3cpath class='st0' d='M95.9,23.9c-0.1-0.6-0.6-1-1.1-1c-0.5,0-9.3-0.2-9.3-0.2s-7.4-7.2-8.1-7.9c-0.7-0.7-2.2-0.5-2.7-0.3 c0,0-1.4,0.4-3.7,1.1c-0.4-1.3-1-2.8-1.8-4.4c-2.6-5-6.5-7.7-11.1-7.7c0,0,0,0,0,0c-0.3,0-0.6,0-1,0.1c-0.1-0.2-0.3-0.3-0.4-0.5 c-2-2.2-4.6-3.2-7.7-3.1c-6,0.2-12,4.5-16.8,12.2c-3.4,5.4-6,12.2-6.8,17.5c-6.9,2.1-11.7,3.6-11.8,3.7c-3.5,1.1-3.6,1.2-4,4.5 c-0.3,2.5-9.5,73-9.5,73l76.4,13.2l33.1-8.2C109.5,115.8,96,24.5,95.9,23.9z M67.2,16.8c-1.8,0.5-3.8,1.2-5.9,1.8 c0-3-0.4-7.3-1.8-10.9C64,8.6,66.2,13.7,67.2,16.8z M57.2,19.9c-4,1.2-8.4,2.6-12.8,3.9c1.2-4.7,3.6-9.4,6.4-12.5 c1.1-1.1,2.6-2.4,4.3-3.2C56.9,11.6,57.3,16.5,57.2,19.9z M49.1,4c1.4,0,2.6,0.3,3.6,0.9C51.1,5.8,49.5,7,48,8.6 c-3.8,4.1-6.7,10.5-7.9,16.6c-3.6,1.1-7.2,2.2-10.5,3.2C31.7,18.8,39.8,4.3,49.1,4z'/%3e%3cg%3e%3cpath class='st1' d='M94.8,22.9c-0.5,0-9.3-0.2-9.3-0.2s-7.4-7.2-8.1-7.9c-0.3-0.3-0.6-0.4-1-0.5l0,109.7l33.1-8.2 c0,0-13.5-91.3-13.6-92C95.8,23.3,95.3,22.9,94.8,22.9z'/%3e%3cpath class='st2' d='M58,39.9l-3.8,14.4c0,0-4.3-2-9.4-1.6c-7.5,0.5-7.5,5.2-7.5,6.4c0.4,6.4,17.3,7.8,18.3,22.9 c0.7,11.9-6.3,20-16.4,20.6c-12.2,0.8-18.9-6.4-18.9-6.4l2.6-11c0,0,6.7,5.1,12.1,4.7c3.5-0.2,4.8-3.1,4.7-5.1 c-0.5-8.4-14.3-7.9-15.2-21.7c-0.7-11.6,6.9-23.4,23.7-24.4C54.7,38.2,58,39.9,58,39.9z'/%3e%3c/g%3e%3c/g%3e%3c/svg%3e" sizes="any" type="image/svg+xml">
+  </head>
+
+  <% if successful %>
+    <body class="body-success">
+      <div class="app-success">
+        <div class="container">
+          <h1><%= locals[:message] %></h1>
+          <p>You can close this tab and return to your terminal.</p>
+        </div>
+      </div>
+    </body>
+  <% else %>
+    <body class="body-error">
+      <div class="app-error">
+        <div class="container">
+          <h1>Something went wrong!</h1>
+          <p><%= locals[:message] %></p>
+          <br>
+          <br>
+          <p>Return to your terminal and try running the previous command again.</p>
+        </div>
+      </div>
+    </body>
+  <% end %>
+</html>

package/assets/cli-ruby/lib/shopify_cli/assets/post_auth_page/style.css

@@ -0,0 +1,58 @@
+html {
+  font-family: -apple-system, BlinkMacSystemFont, San Francisco, Segoe UI, Roboto, Helvetica Neue, sans-serif;
+  text-size-adjust: 100%;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+body {
+  font-size: 26px;
+  line-height: normal;
+  margin: 0;
+  padding: 0;
+}
+
+button, input, optgroup, select, textarea {
+  font-family: inherit;
+}
+
+h1 {
+  font-weight: 600;
+  font-size: 1em;
+}
+
+p {
+  font-weight: 400;
+}
+
+.body-success {
+  color: #F6F6F7;
+}
+
+.body-error {
+  color: #202223;
+}
+
+.app-success {
+  width: 100vw;
+  height: 100vh;
+  background-color: #054A49;
+  display: flex;
+}
+
+.app-error {
+  width: 100vw;
+  height: 100vh;
+  background-color: #F6F6F7;
+  display: flex;
+}
+
+.container {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  padding-left: 7.5em;
+}