jatai 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b9131e1a51d23a7120a320f01c24d31b332e636467c048bbfddea25bd49b643
-  data.tar.gz: 5306e6ed76d3076ebe707d08f399d9071d63814fe92cd930239a2143113ba87a
+  metadata.gz: 648533180b943e80129355c3308d594f1867fde7946470361f3897ad3cdd06eb
+  data.tar.gz: 2cfe1d3481ef074b1c1e257f0cd2eea369193a6681694d5d2da6a8e6131f4c42
 SHA512:
-  metadata.gz: ed82a595b2b854268d89902e495963b548b6b6a0057d9e846aa01345157fe5c02ea76935901aede74a668be8a8c6ed1c9a7f509702fd27e8f45b37cbf2f382c4
-  data.tar.gz: 17fb609ef8532e4da8d49c8bd1cb8ada50fc3052772db9b4b625de6f6516fb830ab8de27264c9166c30eff5080b2adb0d07c827bda32c7184682a0488746e235
+  metadata.gz: 82d898f647e4109c8842d35d203fd818a170f013f174865ef91e5934a6afc93083e2dd4aa7dd305ef2922d7ab2897c0257f9dbd9fba8c763a021b4707851a7be
+  data.tar.gz: 444b6824a85488f361916f126e34bc68e574c7248bef66d35c51430cdaa9056ad0b18d6880a17ea856d2ef98ca1483f7df71ad991d08729c19630f6b053b99a8

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!

data/lib/jatai/commands/init.rb

@@ -11,7 +11,8 @@ module Jatai
         "pro" => "Pro — 2GB RAM, réplicas ilimitadas (R$ 69/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",
@@ -43,30 +44,48 @@ 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 }
+        name, slug = ask_name_and_slug(prompt)
         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 } })
         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}")
         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/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,7 +92,7 @@ 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]

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.4.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.4.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