jatai 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b9131e1a51d23a7120a320f01c24d31b332e636467c048bbfddea25bd49b643
-  data.tar.gz: 5306e6ed76d3076ebe707d08f399d9071d63814fe92cd930239a2143113ba87a
+  metadata.gz: cce550fef38fbddcb460eaa4d1d5e2631dfc8b43e33d035c607680e24ea6fee6
+  data.tar.gz: 75eaffc25c616af78578cd43b077ef62604852b90a4319d961bc50b4190f067e
 SHA512:
-  metadata.gz: ed82a595b2b854268d89902e495963b548b6b6a0057d9e846aa01345157fe5c02ea76935901aede74a668be8a8c6ed1c9a7f509702fd27e8f45b37cbf2f382c4
-  data.tar.gz: 17fb609ef8532e4da8d49c8bd1cb8ada50fc3052772db9b4b625de6f6516fb830ab8de27264c9166c30eff5080b2adb0d07c827bda32c7184682a0488746e235
+  metadata.gz: b16035861874a14cadbafff211bfb8517d30652187a0d428e377b5e3fff59a2f98aa0a04588bb8819e98aa1114429ea856e89432c7ef40657a987019eb63f4dc
+  data.tar.gz: 8a50d74a29189c5f21f62c1d16a73030fad4031be48a70957c6350c35d4935b14f6e76fd8b0fdb54365cc2f4a667519699e534e66913855293dfa6ac61fb1b29

data/lib/jatai/cli.rb

@@ -88,7 +88,7 @@ module Jatai
 
     desc "scale", "Escalar a aplicação"
     option :replicas, type: :numeric, desc: "Número de réplicas"
-    option :preset, type: :string, desc: "Preset (micro, hobby, pro)"
+    option :preset, type: :string, desc: "Hex (base, escala_1, escala_2)"
     def scale
       Commands::Scale.new.execute(options)
     end

data/lib/jatai/commands/base.rb

@@ -22,8 +22,25 @@ module Jatai
         end
       end
 
+      # SEMPRE slugifica o que veio do arquivo. Isso é o que dá
+      # retrocompatibilidade com os .jatai.yml gerados antes de `app:` passar a
+      # guardar o slug: lá dentro havia o nome de exibição cru ("Alves
+      # Barbearia"), que ia direto para a URL e estourava no URI antes mesmo de
+      # sair a requisição. Slugificar é idempotente, então arquivo novo — que já
+      # traz o slug — atravessa sem alteração.
       def app_slug
-        project_config[:app]
+        raw = project_config[:app]
+        slug = Slug.from(raw)
+        return slug if slug
+
+        abort pastel.red("`app` inválido no .jatai.yml (#{raw.inspect}). " \
+                         "Use letras, números e hífen, ou rode `jatai init` novamente.")
+      end
+
+      # Nome legível. Arquivo novo traz `name:`; no antigo, o próprio `app:` era
+      # o nome de exibição.
+      def app_name
+        project_config[:name] || project_config[:app]
       end
 
       def require_auth!
@@ -31,6 +48,22 @@ module Jatai
         abort pastel.red("Não autenticado. Execute `jatai login` primeiro.")
       end
 
+      # Rótulo do cliente para a unidade computacional. O slug é interno
+      # (`base`, `escala_1`); quem lê a tela lê "Hex Escala 1" — o mesmo texto
+      # que o painel e a fatura mostram (AppsHelper#hex_label no servidor).
+      def hex_label(tier)
+        return "-" if tier.to_s.empty?
+
+        "Hex #{tier.to_s.tr("_", " ").capitalize}"
+      end
+
+      # O banco é um addon; `database_plan` vem nulo no app que não tem nenhum.
+      def pg_label(plan)
+        return "sem banco" if plan.to_s.empty?
+
+        "PG #{plan.to_s.tr("_", " ").capitalize}"
+      end
+
       def success(msg)
         puts pastel.green(msg)
       end
@@ -42,6 +75,12 @@ module Jatai
       def info(msg)
         puts pastel.cyan(msg)
       end
+
+      # Nem verde nem vermelho: o deploy parcial subiu o site e deixou processo
+      # para trás — chamar de sucesso ou de falha mentiria nas duas direções.
+      def warning(msg)
+        puts pastel.yellow(msg)
+      end
     end
   end
 end

data/lib/jatai/commands/database.rb

@@ -14,7 +14,7 @@ module Jatai
         db = helper.api.get("/api/v1/apps/#{slug}/database")
 
         puts helper.pastel.bold("Banco de dados de #{slug}")
-        puts "  Tier:     #{db["database_tier"] || db["mode"]}"
+        puts "  Modo:     #{db["mode"]}"
         puts "  Host:     #{db["host"]}"
         puts "  Porta:    #{db["port"]}"
         puts "  Nome:     #{db["name"]}"

data/lib/jatai/commands/deploy.rb

@@ -44,12 +44,15 @@ module Jatai
 
         status = ws.wait_for("DeployStatusChannel",
           params: { deploy_id: deploy_id },
-          until_status: %w[live failed],
+          until_status: %w[live failed partially_live],
           timeout: DEPLOY_TIMEOUT)
 
         elapsed = (Time.now - started).to_i
-        if status == "live"
+        case status
+        when "live"
           success("\nDeploy concluído com sucesso! (#{elapsed}s)")
+        when "partially_live"
+          print_partial_summary(slug, deploy_id, elapsed)
         else
           error("\nDeploy falhou.")
         end
@@ -74,6 +77,9 @@ module Jatai
           when "live"
             success("\nDeploy concluído com sucesso! (#{(Time.now - started).to_i}s)")
             return
+          when "partially_live"
+            print_partial_summary(slug, deploy_id, (Time.now - started).to_i)
+            return
           when "failed"
             error("\nDeploy falhou.")
             return
@@ -92,6 +98,20 @@ module Jatai
         error("\nTimeout (#{(Time.now - started).to_i}s). Verifique com: jatai status")
       end
 
+      # O deploy parcial é terminal: o site subiu, mas processo(s) declarados
+      # ficaram no release anterior. Sem este ramo a CLI penduraria 20min
+      # esperando um "live" que não vem.
+      def print_partial_summary(slug, deploy_id, elapsed)
+        warning("\nDeploy parcialmente concluído (#{elapsed}s)")
+        deploy = api.get("/api/v1/apps/#{slug}/deploys/#{deploy_id}")
+        Array(deploy["process_failures"]).each do |failure|
+          warning("  #{failure['name']}: #{failure['reason']}")
+        end
+        warning("O site está no ar na versão nova; os processos acima seguem na anterior.")
+      rescue StandardError
+        warning("  (detalhe indisponível — ver o deploy no painel)")
+      end
+
       def status_label(status)
         { "queued" => "Na fila...", "building" => "Construindo imagem...",
           "deploying" => "Deployando..." }[status] || status

data/lib/jatai/commands/init.rb

@@ -5,24 +5,27 @@ require "yaml"
 module Jatai
   module Commands
     class Init < Base
-      PRESETS = {
-        "micro" => "Micro — 256MB RAM, 1 réplica (Grátis)",
-        "hobby" => "Hobby — 1GB RAM, réplicas ilimitadas (R$ 19/mês)",
-        "pro" => "Pro — 2GB RAM, réplicas ilimitadas (R$ 69/mês)"
+      # O Hex é a unidade computacional da plataforma — web e worker custam o
+      # mesmo degrau. Os preços aqui são os que a fatura cobra (Pricing::HEX):
+      # esta lista já anunciou "hobby R$ 19" enquanto a plataforma debitava
+      # R$ 29, e o cliente só descobria na primeira fatura.
+      #
+      # O `Hex Dedicado` (R$ 299) fica de fora: ele reserva 2Gi, 51% do nó k3s
+      # atual, e só fica vendável após o retype da VM.
+      HEX = {
+        "base" => "Hex Base — R$ 29/mês (1 grátis por time)",
+        "escala_1" => "Hex Escala 1 — R$ 59/mês",
+        "escala_2" => "Hex Escala 2 — R$ 119/mês"
       }.freeze
 
-      REGIONS = { "br-se1" => "São Paulo", "br-ne1" => "Nordeste" }.freeze
+      # Região única por enquanto (Sudeste). Quando houver multi-região, volta a ser um prompt.
+      DEFAULT_REGION = "br-se1".freeze
       STACKS = {
         "rails" => "Rails",
         "node" => "Node.js",
         "static" => "Estático (HTML/CSS/JS, sem build)",
         "docker" => "Docker (custom Dockerfile)"
       }.freeze
-      DATABASE_TIERS = {
-        "mini" => "Mini — 512MB, 20 conexões (Grátis)",
-        "essencial" => "Essencial — 1GB, 50 conexões (R$ 19/mês)",
-        "padrao" => "Padrão — 5GB, 100 conexões (R$ 49/mês)"
-      }.freeze
 
       def execute(options = {})
         prompt = TTY::Prompt.new
@@ -43,30 +46,50 @@ module Jatai
           stack = prompt.select("Stack:", STACKS.map { |k, v| { name: v, value: k } })
         end
 
-        name = prompt.ask("Nome do app:") { |q| q.required true }
-        preset = prompt.select("Preset:", PRESETS.map { |k, v| { name: v, value: k } })
-        region = prompt.select("Região:", REGIONS.map { |k, v| { name: "#{v} (#{k})", value: k } })
-        # Sites estáticos não têm banco — não pergunta o tier.
-        db_tier = stack == "static" ? nil : prompt.select("Banco de dados:", DATABASE_TIERS.map { |k, v| { name: v, value: k } })
+        name, slug = ask_name_and_slug(prompt)
+        preset = prompt.select("Hex:", HEX.map { |k, v| { name: v, value: k } })
         branch = detect_git_branch || "main"
 
+        # `app` é o IDENTIFICADOR (slug) usado nas URLs da API; `name` é o nome de
+        # exibição. Antes um único campo servia aos dois papéis, e um nome com
+        # espaço ("Alves Barbearia") ia direto para a URL e estourava no URI.
         config = {
-          "app" => name,
+          "app" => slug,
+          "name" => name,
           "stack" => stack,
           "preset" => preset,
-          "region" => region,
+          "region" => DEFAULT_REGION,
           "branch" => branch
         }
-        config["database_tier"] = db_tier if db_tier
 
         File.write(config_path, YAML.dump(config))
         success("Arquivo .jatai.yml criado com sucesso!")
+        info("Identificador: #{slug}") if slug != name
         info("Branch: #{branch}")
+        # O banco deixou de ser uma pergunta: o Provision::Orchestrator dá um
+        # Postgres a todo app não-estático, e o PG Base do app de cortesia do
+        # time é isento. Escolher tier aqui só antecipava uma decisão que a aba
+        # "Banco de dados" refaz melhor, com o app já rodando.
+        info("Banco: PG Base provisionado automaticamente no `jatai up`.") unless stack == "static"
         info("Execute `jatai up` para criar e fazer deploy do app.")
       end
 
       private
 
+      # O nome é livre; o slug sai dele. Repete a pergunta quando nada
+      # aproveitável sobra (nome só de emoji, por exemplo) em vez de gravar um
+      # `app` vazio que quebraria a primeira requisição.
+      def ask_name_and_slug(prompt)
+        loop do
+          name = prompt.ask("Nome do app:") { |q| q.required true }
+          slug = Slug.from(name)
+          return [ name, slug ] if slug
+
+          error("Não consegui gerar um identificador a partir de #{name.inspect}. " \
+                "Use letras ou números no nome.")
+        end
+      end
+
       def detect_stack
         if File.exist?(File.join(Dir.pwd, "Gemfile"))
           gemfile = File.read(File.join(Dir.pwd, "Gemfile"))

data/lib/jatai/commands/redis.rb

@@ -8,9 +8,9 @@ module Jatai
       namespace :redis
 
       MEMORY_TO_PLAN = {
-        256 => "starter",
-        512 => "pro",
-        1024 => "business"
+        256 => "base",
+        512 => "escala_1",
+        1024 => "escala_2"
       }.freeze
 
       desc "status", "Ver status do Redis"

data/lib/jatai/commands/scale.rb

@@ -18,7 +18,7 @@ module Jatai
         end
 
         estimate = api.post("/api/v1/apps/#{slug}/scale/estimate", body: body)
-        info("Preset: #{estimate["preset"]}")
+        info("Hex: #{hex_label(estimate["preset"])}")
         info("Réplicas: #{estimate["replicas"]}") if estimate["replicas"]
         info("CPU: #{estimate["cpu_limit"]}  |  RAM: #{estimate["memory_limit"]}") if estimate["cpu_limit"]
         info("Custo estimado: R$ #{estimate["monthly_cost"]}/mês")

data/lib/jatai/commands/status.rb

@@ -14,10 +14,16 @@ module Jatai
         puts "  Stack:   #{app["stack"]}"
         puts "  Status:  #{colorize_status(app["status"])}"
         puts "  Região:  #{app["region"]}"
-        puts "  Preset:  #{app["preset"]}"
-        puts "  DB:      #{app["database_tier"]}"
-        subdomain = app["subdomain"] || app["slug"]
-        puts "  URL:     https://#{subdomain}.usebrasa.com.br"
+        puts "  Hex:     #{hex_label(app["preset"])}"
+        # `database_tier` deixou de existir: o tier do banco vive no plano do
+        # addon, e é `database_plan` que a API devolve. Enquanto a CLI lia a
+        # chave antiga, esta linha saía sempre vazia.
+        puts "  Banco:   #{pg_label(app["database_plan"])}"
+        # A URL vem da API (ClientAppSerializer#url), como no `jatai up`: montá-la
+        # aqui hardcodando usebrasa.com.br fazia a CLI anunciar a marca antiga
+        # enquanto a documentação e o dashboard já mostram jataiapp.com.br — e
+        # deixava a CLI errada de novo no próximo passo do rebrand.
+        puts "  URL:     #{app["url"]}" if app["url"]
 
         if app["last_deploy"]
           deploy = app["last_deploy"]

data/lib/jatai/commands/up.rb

@@ -46,14 +46,36 @@ module Jatai
 
       private
 
+      # O slug do .jatai.yml é só o PALPITE: o servidor pode ter desambiguado
+      # com sufixo (alves-barbearia-1) quando o nome já existia, e a partir daí
+      # o arquivo apontaria para sempre para um app que não é o do cliente.
+      # Depois de criar, grava de volta o slug que o servidor devolveu — daí em
+      # diante o arquivo carrega a verdade, não a dedução.
       def find_or_create_app(config)
-        existing = api.get("/api/v1/apps/#{config[:app]}")
+        existing = api.get("/api/v1/apps/#{app_slug}")
         info("App #{existing["slug"]} encontrado (#{existing["status"]}).")
         ensure_repo_url(existing["slug"])
         existing
       rescue Api::Client::NotFoundError
-        info("Criando app #{config[:app]}...")
-        create_app(config)
+        info("Criando app #{app_name}...")
+        created = create_app(config)
+        persist_server_slug(created["slug"])
+        created
+      end
+
+      def persist_server_slug(server_slug)
+        return if server_slug.nil? || server_slug == project_config[:app]
+
+        path = Config.project_file_path
+        raw = YAML.safe_load(File.read(path))
+        raw["name"] ||= raw["app"] # arquivo antigo: `app` guardava o nome
+        raw["app"] = server_slug
+        File.write(path, YAML.dump(raw))
+        info("Identificador do app no .jatai.yml: #{server_slug}")
+      rescue StandardError => e
+        # Não derruba o deploy: o app foi criado e o deploy segue. Só o arquivo
+        # ficou desatualizado, e o próximo comando cai no palpite de novo.
+        warn(pastel.yellow("       Não foi possível gravar o slug no .jatai.yml: #{e.message}"))
       end
 
       def trigger_provision(slug)
@@ -70,10 +92,9 @@ module Jatai
 
       def create_app(config)
         app_params = {
-          name: config[:app], stack: config[:stack], preset: config[:preset],
+          name: app_name, stack: config[:stack], preset: config[:preset],
           region: config[:region], repo_url: detect_git_remote, repo_branch: config[:branch]
         }
-        app_params[:database_tier] = config[:database_tier] if config[:database_tier]
         app_params[:release_command] = config.dig(:release, :command) if config.dig(:release, :command)
         api.post("/api/v1/apps", body: { app: app_params })
       end
@@ -145,11 +166,14 @@ module Jatai
 
         status = ws.wait_for("DeployStatusChannel",
           params: { deploy_id: deploy_id },
-          until_status: %w[live failed],
+          until_status: %w[live failed partially_live],
           timeout: DEPLOY_TIMEOUT)
 
-        if status == "live"
+        case status
+        when "live"
           true
+        when "partially_live"
+          partial_deploy_notice
         else
           error("\nDeploy falhou.")
           false
@@ -166,6 +190,14 @@ module Jatai
         Jatai::Websocket::CableClient.new.tap(&:connect!)
       end
 
+      # `true` porque, para o `up`, o app ESTÁ no ar: o fluxo seguinte (mostrar
+      # a URL) continua válido. O que ficou fora do release sai no painel e no
+      # `jatai deploy`, que tem o resumo completo.
+      def partial_deploy_notice
+        warning("\nDeploy parcialmente concluído — processo(s) fora do release; ver o deploy no painel.")
+        true
+      end
+
       def warn_fallback(err)
         $stderr.puts "\n       [WebSocket indisponível: #{err.message}. Usando polling...]"
       end
@@ -205,6 +237,7 @@ module Jatai
         DEPLOY_MAX_POLLS.times do |i|
           deploy = api.get("/api/v1/apps/#{slug}/deploys/#{deploy_id}")
           return true if deploy["status"] == "live"
+          return partial_deploy_notice if deploy["status"] == "partially_live"
           if deploy["status"] == "failed"
             error("\nDeploy falhou.")
             return false

data/lib/jatai/slug.rb

@@ -0,0 +1,40 @@
+module Jatai
+  # Converte texto livre no identificador que o servidor usa na URL.
+  #
+  # O servidor gera o slug com `name.parameterize` (ActiveSupport) e o valida
+  # com /\A[a-z0-9]([a-z0-9\-]*[a-z0-9])?\z/. A CLI não depende de
+  # ActiveSupport — carregá-la inteira por uma função encareceria o boot — então
+  # a transliteração é feita à mão para o conjunto que os clientes de fato usam
+  # (português). Caracteres fora dessa tabela são descartados, e é por isso que
+  # esta conversão é só o PALPITE da primeira requisição: quem manda no slug é o
+  # servidor, e o `jatai up` grava de volta no .jatai.yml o slug que ele retorna.
+  #
+  # Idempotente: aplicar sobre um slug válido devolve o mesmo slug. É o que dá
+  # retrocompatibilidade com os .jatai.yml antigos, em que `app:` guardava o
+  # nome de exibição — "Alves Barbearia" vira "alves-barbearia", que é
+  # exatamente o slug que o servidor gerou na criação daquele app.
+  module Slug
+    TRANSLITERATIONS = {
+      "á" => "a", "à" => "a", "â" => "a", "ã" => "a", "ä" => "a", "å" => "a",
+      "é" => "e", "è" => "e", "ê" => "e", "ë" => "e",
+      "í" => "i", "ì" => "i", "î" => "i", "ï" => "i",
+      "ó" => "o", "ò" => "o", "ô" => "o", "õ" => "o", "ö" => "o",
+      "ú" => "u", "ù" => "u", "û" => "u", "ü" => "u",
+      "ç" => "c", "ñ" => "n", "ý" => "y"
+    }.freeze
+
+    module_function
+
+    # nil quando não sobra nada utilizável — quem chama decide o que dizer ao
+    # usuário. Devolver "" mandaria uma URL vazia para a API.
+    def from(text)
+      return nil if text.nil?
+
+      slug = text.to_s.downcase
+      slug = slug.gsub(/[^a-z0-9\-]/) { |char| TRANSLITERATIONS.fetch(char, "-") }
+      slug = slug.gsub(/-+/, "-").gsub(/\A-|-\z/, "")
+
+      slug.empty? ? nil : slug
+    end
+  end
+end

data/lib/jatai/version.rb

@@ -1,3 +1,3 @@
 module Jatai
-  VERSION = "1.3.0"
+  VERSION = "1.5.0"
 end

data/lib/jatai.rb

@@ -1,5 +1,6 @@
 require "jatai/version"
 require "jatai/config"
+require "jatai/slug"
 require "jatai/api/client"
 require "jatai/cli"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jatai
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Jataí Cloud
@@ -181,6 +181,7 @@ files:
 - lib/jatai/commands/status.rb
 - lib/jatai/commands/up.rb
 - lib/jatai/config.rb
+- lib/jatai/slug.rb
 - lib/jatai/source_packer.rb
 - lib/jatai/version.rb
 - lib/jatai/websocket/cable_client.rb