multiapi_cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c0b2ae858627c36ab5bd20d0ad9209a6d2c3e23202c9730e71a6d6eda5b0486
+  data.tar.gz: ae75a299c282a737b66319f49b26e2c3a5eb97b1c48e937d53ba7051a7281ac7
+SHA512:
+  metadata.gz: d85a70142782c93d66f07a983ac74229a10abdf4345a715376568d6241dbd97c64a4c865d918c3fa49ffc12bdb68d55ae505aeefc4eee76099b8076cb5954841
+  data.tar.gz: 110ffcff5e93bdf7f53475ec42265c51f294b3b93754eda00b24b31bab7b1ca6ee7b30da8d4888f147cf729366393690460ad0bb7922904a6e6243e8c0f9755e

data/README.md

@@ -0,0 +1,33 @@
+# Multiapi CLI
+
+Uma CLI para gerenciar projetos Multiapi, integrando geradores do Rails e Nuxt.
+
+## Instalação
+
+```bash
+cd cli
+bundle install
+bundle exec rake install
+```
+
+## Uso
+
+```bash
+multiapi generate
+```
+
+A CLI irá perguntar interativamente:
+- O que você deseja criar:
+  - Recurso Completo (API + Frontend)
+  - Apenas API
+  - Apenas Frontend
+- O nome do recurso que você quer criar
+
+## Desenvolvimento
+
+Para desenvolver a CLI:
+
+1. Clone o repositório
+2. Execute `bundle install`
+3. Faça suas alterações
+4. Execute `bundle exec rake install` para testar localmente 

data/exe/multiapi

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require_relative "../lib/multiapi_cli"
+
+MultiapiCli::CLI.start(ARGV) 

data/lib/multiapi_cli/version.rb

@@ -0,0 +1,3 @@
+module MultiapiCli
+  VERSION = "0.1.0"
+end 

data/lib/multiapi_cli.rb

@@ -0,0 +1,1041 @@
+require "thor"
+require "tty-prompt"
+require "tty-spinner"
+require "active_support/core_ext/string/inflections"
+require "fileutils"
+
+module MultiapiCli
+  class Error < StandardError; end
+  
+  class CLI < Thor
+    desc "generate COMPONENT", "Gera um novo componente na estrutura Multiapi"
+    def generate
+      prompt = TTY::Prompt.new
+      
+      type = prompt.select("O que você deseja criar?") do |menu|
+        menu.choice "Recurso Completo (API + Frontend)", :full_resource
+        menu.choice "Apenas API", :api_only
+        menu.choice "Apenas Frontend", :frontend_only
+      end
+      
+      name = prompt.ask("Nome do recurso:", required: true)
+      
+      scope = prompt.select("Qual o escopo do recurso?") do |menu|
+        menu.choice "Admin - Área Administrativa", :admin
+        menu.choice "User - Área do Usuário", :user
+      end
+      
+      case type
+      when :full_resource
+        generate_full_resource(name, scope)
+      when :api_only
+        generate_api_resource(name, scope)
+      when :frontend_only
+        generate_frontend_resource(name, scope)
+      end
+    end
+    
+    private
+    
+    def generate_app_vue_content
+      <<~VUE
+      <template>
+        <NuxtLayout>
+          <NuxtPage />
+        </NuxtLayout>
+      </template>
+      VUE
+    end
+
+    def generate_layout_content(scope)
+      <<~VUE
+      <template>
+        <div class="#{scope}-layout">
+          <header class="#{scope}-header">
+            <!-- Add your header content here -->
+          </header>
+          
+          <main class="#{scope}-main">
+            <slot />
+          </main>
+          
+          <footer class="#{scope}-footer">
+            <!-- Add your footer content here -->
+          </footer>
+        </div>
+      </template>
+
+      <script setup lang="ts">
+      // Add your layout logic here
+      </script>
+
+      <style scoped>
+      .#{scope}-layout {
+        min-height: 100vh;
+        display: flex;
+        flex-direction: column;
+      }
+
+      .#{scope}-main {
+        flex: 1;
+        padding: 20px;
+      }
+      </style>
+      VUE
+    end
+
+    def generate_page_content(name, scope)
+      resource_name = name.downcase
+      plural_name = resource_name.pluralize
+      component_name = "#{scope.capitalize}#{plural_name.camelize}Index"
+
+      <<~VUE
+      <template>
+        <div class="#{plural_name}-page">
+          <#{component_name} />
+        </div>
+      </template>
+
+      <script setup lang="ts">
+      import { definePageMeta } from '#imports'
+      import #{component_name} from '../../components/#{scope}/#{plural_name}/index.vue'
+      import { use#{plural_name.camelize}Store } from '../../stores/#{scope}/#{plural_name}'
+
+      definePageMeta({
+        layout: '#{scope}'
+      })
+      </script>
+
+      <style scoped>
+      .#{plural_name}-page {
+        padding: 0;
+      }
+      </style>
+      VUE
+    end
+
+    def generate_component_content(name, scope)
+      resource_name = name.downcase
+      plural_name = resource_name.pluralize
+      singular_name = resource_name.singularize
+
+      <<~VUE
+      <template>
+        <div class="#{plural_name}-component">
+          <Card v-if="store.loading" class="w-full">
+            <CardHeader>
+              <CardTitle>Carregando...</CardTitle>
+            </CardHeader>
+            <CardContent class="flex items-center justify-center">
+              <div class="h-8 w-8 animate-spin rounded-full border-4 border-primary border-t-transparent"></div>
+            </CardContent>
+          </Card>
+          
+          <Alert v-else-if="store.error" variant="destructive">
+            <AlertTitle>Erro</AlertTitle>
+            <AlertDescription>{{ store.error }}</AlertDescription>
+          </Alert>
+          
+          <div v-else class="space-y-4">
+            <div class="flex items-center justify-between">
+              <h1 class="text-2xl font-bold">#{plural_name.titleize}</h1>
+              <Button @click="showCreateModal = true" variant="default">
+                <PlusIcon class="mr-2 h-4 w-4" />
+                Novo #{singular_name.titleize}
+              </Button>
+            </div>
+
+            <Card class="w-full">
+              <Table>
+                <TableHeader>
+                  <TableRow>
+                    <TableHead v-for="key in Object.keys(store.get#{plural_name.camelize}[0] || {})" :key="key">
+                      {{ key }}
+                    </TableHead>
+                    <TableHead>Ações</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  <TableRow v-for="item in store.get#{plural_name.camelize}" :key="item.id">
+                    <TableCell v-for="(value, key) in item" :key="key">
+                      {{ value }}
+                    </TableCell>
+                    <TableCell>
+                      <div class="flex space-x-2">
+                        <Button @click="openEditModal(item)" variant="outline" size="sm">
+                          <PencilIcon class="h-4 w-4" />
+                        </Button>
+                        <Button @click="confirmDelete(item)" variant="destructive" size="sm">
+                          <TrashIcon class="h-4 w-4" />
+                        </Button>
+                      </div>
+                    </TableCell>
+                  </TableRow>
+                </TableBody>
+              </Table>
+            </Card>
+
+            <Dialog :open="showCreateModal" @update:open="showCreateModal = $event">
+              <DialogContent>
+                <DialogHeader>
+                  <DialogTitle>Criar Novo #{singular_name.titleize}</DialogTitle>
+                </DialogHeader>
+                <#{scope}#{singular_name.camelize}Create
+                  @success="handleCreateSuccess"
+                  @cancel="showCreateModal = false"
+                />
+              </DialogContent>
+            </Dialog>
+
+            <Dialog :open="showEditModal" @update:open="showEditModal = $event">
+              <DialogContent>
+                <DialogHeader>
+                  <DialogTitle>Editar #{singular_name.titleize}</DialogTitle>
+                </DialogHeader>
+                <#{scope}#{singular_name.camelize}Edit
+                  :id="selectedItem?.id"
+                  @success="handleEditSuccess"
+                  @cancel="showEditModal = false"
+                />
+              </DialogContent>
+            </Dialog>
+          </div>
+        </div>
+      </template>
+
+      <script setup lang="ts">
+      import { onMounted, ref } from 'vue'
+      import { use#{plural_name.camelize}Store } from '../../../stores/#{scope}/#{plural_name}'
+      import #{scope}#{singular_name.camelize}Create from './create.vue'
+      import #{scope}#{singular_name.camelize}Edit from './edit.vue'
+      import { Button } from '@/components/ui/button'
+      import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'
+      import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+      import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/components/ui/dialog'
+      import { Alert, AlertTitle, AlertDescription } from '@/components/ui/alert'
+      import { PlusIcon, PencilIcon, TrashIcon } from 'lucide-vue-next'
+
+      const store = use#{plural_name.camelize}Store()
+      const showCreateModal = ref(false)
+      const showEditModal = ref(false)
+      const selectedItem = ref(null)
+
+      onMounted(async () => {
+        await store.fetch#{plural_name.camelize}()
+      })
+
+      const openEditModal = (item) => {
+        selectedItem.value = item
+        showEditModal.value = true
+      }
+
+      const handleCreateSuccess = async () => {
+        showCreateModal.value = false
+        await store.fetch#{plural_name.camelize}()
+      }
+
+      const handleEditSuccess = async () => {
+        showEditModal.value = false
+        await store.fetch#{plural_name.camelize}()
+      }
+
+      const confirmDelete = async (item) => {
+        if (confirm(`Deseja realmente excluir este #{singular_name}?`)) {
+          try {
+            await store.delete#{singular_name.camelize}(item.id)
+            await store.fetch#{plural_name.camelize}()
+          } catch (error) {
+            console.error('Erro ao excluir #{singular_name}:', error)
+          }
+        }
+      }
+      </script>
+
+      <style scoped>
+      .#{plural_name}-component {
+        padding: 0;
+      }
+
+      .loading {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        padding: 40px;
+      }
+
+      .spinner {
+        width: 40px;
+        height: 40px;
+        border: 4px solid #f3f3f3;
+        border-top: 4px solid #3498db;
+        border-radius: 50%;
+        animation: spin 1s linear infinite;
+      }
+
+      @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+      }
+
+      .error {
+        color: #dc3545;
+        padding: 20px;
+        text-align: center;
+      }
+
+      .header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 20px;
+      }
+
+      .items {
+        display: grid;
+        grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+        gap: 20px;
+      }
+
+      .item {
+        border: 1px solid #ddd;
+        border-radius: 8px;
+        padding: 15px;
+      }
+
+      .item-content {
+        margin-bottom: 15px;
+      }
+
+      .field {
+        margin-bottom: 8px;
+      }
+
+      .item-actions {
+        display: flex;
+        gap: 10px;
+        justify-content: flex-end;
+      }
+
+      .modal {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        z-index: 1000;
+      }
+
+      .modal-overlay {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+      }
+
+      .modal-content {
+        position: relative;
+        background: white;
+        border-radius: 8px;
+        width: 90%;
+        max-width: 500px;
+        z-index: 1001;
+      }
+
+      .btn-primary {
+        background: #3498db;
+        color: white;
+        border: none;
+        padding: 8px 16px;
+        border-radius: 4px;
+        cursor: pointer;
+      }
+
+      .btn-secondary {
+        background: #2ecc71;
+        color: white;
+        border: none;
+        padding: 8px 16px;
+        border-radius: 4px;
+        cursor: pointer;
+      }
+
+      .btn-danger {
+        background: #e74c3c;
+        color: white;
+        border: none;
+        padding: 8px 16px;
+        border-radius: 4px;
+        cursor: pointer;
+      }
+
+      button:disabled {
+        opacity: 0.7;
+        cursor: not-allowed;
+      }
+      </style>
+      VUE
+    end
+
+    def resource_exists_in_api?(name)
+      # Verifica se existe o controller
+      File.exist?(File.join(api_path, "app/controllers/#{name.downcase.pluralize}_controller.rb")) ||
+      # Verifica se existe o model
+      File.exist?(File.join(api_path, "app/models/#{name.downcase.singularize}.rb"))
+    end
+    
+    def resource_exists_in_frontend?(name, scope)
+      # Verifica se existe a página no diretório correto
+      File.exist?(File.join(frontend_path, "pages/#{scope}/#{name.downcase.pluralize}.vue")) ||
+      # Verifica se existe o componente no diretório correto
+      File.exist?(File.join(frontend_path, "components/#{scope}/#{name.downcase.pluralize}/index.vue"))
+    end
+    
+    def api_path
+      File.expand_path("../../api", __dir__)
+    end
+    
+    def frontend_path
+      File.expand_path("../../web", __dir__)
+    end
+
+    def generate_store_content(name, scope)
+      resource_name = name.downcase
+      plural_name = resource_name.pluralize
+      singular_name = resource_name.singularize
+
+      # Template do store usando Pinia
+      <<~STORE
+      import { defineStore } from 'pinia'
+      import { useApi } from '@/services/api'
+
+      export const use#{plural_name.camelize}Store = defineStore('#{scope}_#{plural_name}', {
+        state: () => ({
+          #{plural_name}: [],
+          #{singular_name}: null,
+          loading: false,
+          error: null
+        }),
+        
+        actions: {
+          async fetch#{plural_name.camelize}() {
+            const api = useApi()
+            this.loading = true
+            try {
+              const response = await api.get('/#{plural_name}')
+              this.#{plural_name} = response.data
+              this.error = null
+            } catch (err) {
+              this.error = err.message
+              console.error('Error fetching #{plural_name}:', err)
+            } finally {
+              this.loading = false
+            }
+          },
+
+          async fetch#{singular_name.camelize}(id) {
+            const api = useApi()
+            this.loading = true
+            try {
+              const response = await api.get(`/#{plural_name}/${id}`)
+              this.#{singular_name} = response.data
+              this.error = null
+            } catch (err) {
+              this.error = err.message
+              console.error('Error fetching #{singular_name}:', err)
+            } finally {
+              this.loading = false
+            }
+          },
+
+          async create#{singular_name.camelize}(data) {
+            const api = useApi()
+            this.loading = true
+            try {
+              const response = await api.post('/#{plural_name}', data)
+              this.#{plural_name}.push(response.data)
+              this.error = null
+              return response.data
+            } catch (err) {
+              this.error = err.message
+              console.error('Error creating #{singular_name}:', err)
+              throw err
+            } finally {
+              this.loading = false
+            }
+          },
+
+          async update#{singular_name.camelize}(id, data) {
+            const api = useApi()
+            this.loading = true
+            try {
+              const response = await api.put(`/#{plural_name}/${id}`, data)
+              const index = this.#{plural_name}.findIndex(item => item.id === id)
+              if (index !== -1) {
+                this.#{plural_name}[index] = response.data
+              }
+              this.error = null
+              return response.data
+            } catch (err) {
+              this.error = err.message
+              console.error('Error updating #{singular_name}:', err)
+              throw err
+            } finally {
+              this.loading = false
+            }
+          },
+
+          async delete#{singular_name.camelize}(id) {
+            const api = useApi()
+            this.loading = true
+            try {
+              await api.delete(`/#{plural_name}/${id}`)
+              this.#{plural_name} = this.#{plural_name}.filter(item => item.id !== id)
+              this.error = null
+            } catch (err) {
+              this.error = err.message
+              console.error('Error deleting #{singular_name}:', err)
+              throw err
+            } finally {
+              this.loading = false
+            }
+          }
+        },
+
+        getters: {
+          get#{plural_name.camelize}: state => state.#{plural_name},
+          get#{singular_name.camelize}: state => state.#{singular_name},
+          isLoading: state => state.loading,
+          getError: state => state.error
+        }
+      })
+      STORE
+    end
+    
+    def generate_full_resource(name, scope)
+      spinner = TTY::Spinner.new("[:spinner] Verificando e gerando recurso #{name} no escopo #{scope}...")
+      spinner.auto_spin
+      
+      api_exists = resource_exists_in_api?(name)
+      frontend_exists = resource_exists_in_frontend?(name, scope)
+      
+      if api_exists && frontend_exists
+        spinner.error("Recurso #{name} já existe tanto na API quanto no Frontend!")
+        return
+      end
+      
+      unless api_exists
+        if File.directory?(api_path)
+          # Verifica se é o model User, que é um caso especial
+          if name.downcase == "user"
+            puts "! Model User já existe, pulando geração do model..."
+            # Gera apenas o controller e rotas para o User
+            system("cd #{api_path} && rails generate controller #{name.pluralize}")
+          else
+            # Para outros recursos, gera o scaffold completo
+            system("cd #{api_path} && rails generate scaffold #{name}")
+          end
+          puts "✓ API gerada com sucesso!"
+        else
+          puts "✗ Diretório da API não encontrado em #{api_path}"
+        end
+      else
+        puts "! API já existe, pulando geração..."
+      end
+      
+      unless frontend_exists
+        if File.directory?(frontend_path)
+          # Cria diretórios necessários
+          FileUtils.mkdir_p(File.join(frontend_path, "layouts"))
+          FileUtils.mkdir_p(File.join(frontend_path, "pages/#{scope}"))
+          FileUtils.mkdir_p(File.join(frontend_path, "components/#{scope}/#{name.downcase.pluralize}"))
+          FileUtils.mkdir_p(File.join(frontend_path, "stores/#{scope}"))
+          
+          # Gera os arquivos manualmente
+          # Gera a página
+          page_path = File.join(frontend_path, "pages/#{scope}/#{name.downcase.pluralize}.vue")
+          File.write(page_path, generate_page_content(name, scope))
+          
+          # Gera os componentes
+          components_dir = File.join(frontend_path, "components/#{scope}/#{name.downcase.pluralize}")
+          
+          # Componente principal (index.vue)
+          File.write(File.join(components_dir, "index.vue"), generate_component_content(name, scope))
+          
+          # Componente de criação (create.vue)
+          create_path = File.join(components_dir, "create.vue")
+          File.write(create_path, generate_create_form_content(name, scope))
+          
+          # Componente de edição (edit.vue)
+          edit_path = File.join(components_dir, "edit.vue")
+          File.write(edit_path, generate_edit_form_content(name, scope))
+          
+          # Gera o store
+          store_path = File.join(frontend_path, "stores/#{scope}/#{name.downcase.pluralize}.ts")
+          File.write(store_path, generate_store_content(name, scope))
+          
+          puts "✓ Frontend gerado com sucesso no escopo #{scope}!"
+          puts "✓ Componentes gerados:"
+          puts "  - #{page_path}"
+          puts "  - #{components_dir}/index.vue"
+          puts "  - #{components_dir}/create.vue"
+          puts "  - #{components_dir}/edit.vue"
+          puts "  - #{store_path}"
+        else
+          puts "✗ Diretório do Frontend não encontrado em #{frontend_path}"
+        end
+      else
+        puts "! Frontend já existe no escopo #{scope}, pulando geração..."
+      end
+      
+      spinner.success("Processo finalizado!")
+    end
+    
+    def generate_api_resource(name, scope)
+      spinner = TTY::Spinner.new("[:spinner] Verificando e gerando API #{name}...")
+      spinner.auto_spin
+      
+      if resource_exists_in_api?(name)
+        spinner.error("API #{name} já existe!")
+        return
+      end
+      
+      if File.directory?(api_path)
+        # Verifica se é o model User, que é um caso especial
+        if name.downcase == "user"
+          puts "! Model User já existe, pulando geração do model..."
+          # Gera apenas o controller e rotas para o User
+          system("cd #{api_path} && rails generate controller #{name.pluralize}")
+        else
+          # Para outros recursos, gera o scaffold completo
+          system("cd #{api_path} && rails generate scaffold #{name}")
+        end
+        spinner.success("API #{name} gerada com sucesso!")
+      else
+        spinner.error("Diretório da API não encontrado em #{api_path}")
+      end
+    end
+    
+    def extract_controller_params(name)
+      controller_path = File.join(api_path, "app/controllers/#{name.downcase.pluralize}_controller.rb")
+      return [] unless File.exist?(controller_path)
+
+      content = File.read(controller_path)
+      
+      # Procura pelo método strong parameters (normalmente chamado de resource_params)
+      if content =~ /def\s+(?:#{name.downcase.singularize}_params|resource_params|permitted_params).*?params\.require\(:#{name.downcase.singularize}\)\.permit\((.*?)\)/m
+        params_string = $1
+        # Extrai os parâmetros permitidos
+        params = params_string.scan(/:(\w+)/).flatten
+        
+        # Mapeia os parâmetros para seus tipos baseado em convenções comuns
+        params.map do |param|
+          field_type = case param
+          when /(date|time)/i
+            'datetime-local'
+          when /email/i
+            'email'
+          when /password/i
+            'password'
+          when /phone/i
+            'tel'
+          when /price|cost|value|amount/i
+            'number'
+          when /description|content|text/i
+            'textarea'
+          when /status|type|category|kind/i
+            'select'
+          when /active|enabled|published|featured/i
+            'checkbox'
+          else
+            'text'
+          end
+
+          {
+            name: param,
+            label: param.humanize,
+            type: field_type,
+            placeholder: "Digite #{param.humanize.downcase}",
+            required: !(param =~ /description|notes|optional/)
+          }
+        end
+      else
+        # Se não encontrar os parâmetros, retorna campos padrão
+        [
+          {
+            name: 'name',
+            label: 'Nome',
+            type: 'text',
+            placeholder: 'Digite o nome',
+            required: true
+          }
+        ]
+      end
+    end
+
+    def generate_create_form_content(name, scope)
+      resource_name = name.downcase
+      plural_name = resource_name.pluralize
+      singular_name = resource_name.singularize
+      
+      fields = extract_controller_params(name)
+      field_definitions = fields.map do |field|
+        <<~FIELD
+          { 
+            name: '#{field[:name]}',
+            label: '#{field[:label]}',
+            type: '#{field[:type]}',
+            placeholder: '#{field[:placeholder]}',
+            required: #{field[:required]}
+          }
+        FIELD
+      end.join(",\n        ")
+
+      schema_validations = fields.map do |field|
+        validation = if field[:required]
+          "#{field[:name]}: z.string().min(1, '#{field[:label]} é obrigatório')"
+        else
+          "#{field[:name]}: z.string().optional()"
+        end
+
+        validation
+      end.join(",\n          ")
+
+      <<~VUE
+      <template>
+        <Form @submit="onSubmit" :validation-schema="schema" v-slot="{ errors }">
+          <div class="space-y-4">
+            <FormField
+              v-for="field in fields"
+              :key="field.name"
+              :name="field.name"
+              v-slot="{ field: formField, errorMessage }"
+            >
+              <FormItem>
+                <FormLabel>{{ field.label }}</FormLabel>
+                <FormControl>
+                  <template v-if="field.type === 'textarea'">
+                    <Textarea
+                      v-bind="formField"
+                      :placeholder="field.placeholder"
+                      :required="field.required"
+                    />
+                  </template>
+                  <template v-else-if="field.type === 'select'">
+                    <Select v-bind="formField">
+                      <SelectTrigger>
+                        <SelectValue :placeholder="field.placeholder" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectGroup>
+                          <SelectLabel>{{ field.label }}</SelectLabel>
+                          <SelectItem v-for="option in field.options" :key="option.value" :value="option.value">
+                            {{ option.label }}
+                          </SelectItem>
+                        </SelectGroup>
+                      </SelectContent>
+                    </Select>
+                  </template>
+                  <template v-else-if="field.type === 'checkbox'">
+                    <Checkbox v-bind="formField" />
+                  </template>
+                  <template v-else>
+                    <Input
+                      v-bind="formField"
+                      :type="field.type"
+                      :placeholder="field.placeholder"
+                      :required="field.required"
+                    />
+                  </template>
+                </FormControl>
+                <FormMessage>{{ errorMessage }}</FormMessage>
+              </FormItem>
+            </FormField>
+
+            <div class="flex justify-end space-x-2">
+              <Button type="button" variant="outline" @click="$emit('cancel')">
+                Cancelar
+              </Button>
+              <Button type="submit" :disabled="isSubmitting">
+                <div v-if="isSubmitting" class="mr-2 h-4 w-4 animate-spin rounded-full border-2 border-current border-t-transparent"></div>
+                Criar
+              </Button>
+            </div>
+          </div>
+        </Form>
+      </template>
+
+      <script setup lang="ts">
+      import { ref } from 'vue'
+      import { Form } from 'vee-validate'
+      import * as z from 'zod'
+      import { toFormValidator } from '@vee-validate/zod'
+      import { use#{plural_name.camelize}Store } from '../../../stores/#{scope}/#{plural_name}'
+      import { Button } from '@/components/ui/button'
+      import { Input } from '@/components/ui/input'
+      import { Textarea } from '@/components/ui/textarea'
+      import { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectTrigger, SelectValue } from '@/components/ui/select'
+      import { Checkbox } from '@/components/ui/checkbox'
+      import { Form as FormRoot, FormControl, FormField, FormItem, FormLabel, FormMessage } from '@/components/ui/form'
+
+      const store = use#{plural_name.camelize}Store()
+      const isSubmitting = ref(false)
+
+      const fields = [
+        #{field_definitions}
+      ]
+
+      const schema = toFormValidator(
+        z.object({
+          #{schema_validations}
+        })
+      )
+
+      const onSubmit = async (values) => {
+        try {
+          isSubmitting.value = true
+          await store.create#{singular_name.camelize}(values)
+          $emit('success')
+        } catch (error) {
+          console.error('Erro ao criar #{singular_name}:', error)
+        } finally {
+          isSubmitting.value = false
+        }
+      }
+      </script>
+      VUE
+    end
+
+    def generate_edit_form_content(name, scope)
+      resource_name = name.downcase
+      plural_name = resource_name.pluralize
+      singular_name = resource_name.singularize
+      
+      fields = extract_controller_params(name)
+      field_definitions = fields.map do |field|
+        <<~FIELD
+          { 
+            name: '#{field[:name]}',
+            label: '#{field[:label]}',
+            type: '#{field[:type]}',
+            placeholder: '#{field[:placeholder]}',
+            required: #{field[:required]}
+          }
+        FIELD
+      end.join(",\n        ")
+
+      schema_validations = fields.map do |field|
+        validation = if field[:required]
+          "#{field[:name]}: z.string().min(1, '#{field[:label]} é obrigatório')"
+        else
+          "#{field[:name]}: z.string().optional()"
+        end
+
+        validation
+      end.join(",\n          ")
+
+      <<~VUE
+      <template>
+        <div v-if="isLoading" class="flex items-center justify-center p-4">
+          <div class="h-8 w-8 animate-spin rounded-full border-4 border-primary border-t-transparent"></div>
+        </div>
+
+        <Form
+          v-else
+          @submit="onSubmit"
+          :validation-schema="schema"
+          :initial-values="formData"
+          v-slot="{ errors }"
+        >
+          <div class="space-y-4">
+            <FormField
+              v-for="field in fields"
+              :key="field.name"
+              :name="field.name"
+              v-slot="{ field: formField, errorMessage }"
+            >
+              <FormItem>
+                <FormLabel>{{ field.label }}</FormLabel>
+                <FormControl>
+                  <template v-if="field.type === 'textarea'">
+                    <Textarea
+                      v-bind="formField"
+                      :placeholder="field.placeholder"
+                      :required="field.required"
+                    />
+                  </template>
+                  <template v-else-if="field.type === 'select'">
+                    <Select v-bind="formField">
+                      <SelectTrigger>
+                        <SelectValue :placeholder="field.placeholder" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectGroup>
+                          <SelectLabel>{{ field.label }}</SelectLabel>
+                          <SelectItem v-for="option in field.options" :key="option.value" :value="option.value">
+                            {{ option.label }}
+                          </SelectItem>
+                        </SelectGroup>
+                      </SelectContent>
+                    </Select>
+                  </template>
+                  <template v-else-if="field.type === 'checkbox'">
+                    <Checkbox v-bind="formField" />
+                  </template>
+                  <template v-else>
+                    <Input
+                      v-bind="formField"
+                      :type="field.type"
+                      :placeholder="field.placeholder"
+                      :required="field.required"
+                    />
+                  </template>
+                </FormControl>
+                <FormMessage>{{ errorMessage }}</FormMessage>
+              </FormItem>
+            </FormField>
+
+            <div class="flex justify-end space-x-2">
+              <Button type="button" variant="outline" @click="$emit('cancel')">
+                Cancelar
+              </Button>
+              <Button type="submit" :disabled="isSubmitting">
+                <div v-if="isSubmitting" class="mr-2 h-4 w-4 animate-spin rounded-full border-2 border-current border-t-transparent"></div>
+                Salvar
+              </Button>
+            </div>
+          </div>
+        </Form>
+      </template>
+
+      <script setup lang="ts">
+      import { ref, onMounted } from 'vue'
+      import { Form } from 'vee-validate'
+      import * as z from 'zod'
+      import { toFormValidator } from '@vee-validate/zod'
+      import { use#{plural_name.camelize}Store } from '../../../stores/#{scope}/#{plural_name}'
+      import { Button } from '@/components/ui/button'
+      import { Input } from '@/components/ui/input'
+      import { Textarea } from '@/components/ui/textarea'
+      import { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectTrigger, SelectValue } from '@/components/ui/select'
+      import { Checkbox } from '@/components/ui/checkbox'
+      import { Form as FormRoot, FormControl, FormField, FormItem, FormLabel, FormMessage } from '@/components/ui/form'
+
+      const props = defineProps<{
+        id: string | number
+      }>()
+
+      const store = use#{plural_name.camelize}Store()
+      const isSubmitting = ref(false)
+      const isLoading = ref(true)
+      const formData = ref({})
+
+      const fields = [
+        #{field_definitions}
+      ]
+
+      const schema = toFormValidator(
+        z.object({
+          #{schema_validations}
+        })
+      )
+
+      onMounted(async () => {
+        try {
+          const data = await store.fetch#{singular_name.camelize}(props.id)
+          formData.value = data
+        } catch (error) {
+          console.error('Erro ao carregar #{singular_name}:', error)
+        } finally {
+          isLoading.value = false
+        }
+      })
+
+      const onSubmit = async (values) => {
+        try {
+          isSubmitting.value = true
+          await store.update#{singular_name.camelize}(props.id, values)
+          $emit('success')
+        } catch (error) {
+          console.error('Erro ao atualizar #{singular_name}:', error)
+        } finally {
+          isSubmitting.value = false
+        }
+      }
+      </script>
+      VUE
+    end
+    
+    def generate_frontend_resource(name, scope)
+      spinner = TTY::Spinner.new("[:spinner] Verificando e gerando Frontend #{name} no escopo #{scope}...")
+      spinner.auto_spin
+
+      begin
+        if resource_exists_in_frontend?(name, scope)
+          spinner.error("Frontend #{name} já existe no escopo #{scope}!")
+          return
+        end
+
+        if File.directory?(frontend_path)
+          # Atualiza app.vue se não existir
+          app_vue_path = File.join(frontend_path, "app.vue")
+          unless File.exist?(app_vue_path)
+            File.write(app_vue_path, generate_app_vue_content)
+          end
+
+          # Cria diretórios necessários
+          FileUtils.mkdir_p(File.join(frontend_path, "layouts"))
+          FileUtils.mkdir_p(File.join(frontend_path, "pages/#{scope}"))
+          FileUtils.mkdir_p(File.join(frontend_path, "components/#{scope}/#{name.downcase.pluralize}"))
+          FileUtils.mkdir_p(File.join(frontend_path, "stores/#{scope}"))
+
+          # Gera o layout do escopo se não existir
+          layout_path = File.join(frontend_path, "layouts/#{scope}.vue")
+          unless File.exist?(layout_path)
+            File.write(layout_path, generate_layout_content(scope))
+          end
+
+          # Gera a página
+          page_path = File.join(frontend_path, "pages/#{scope}/#{name.downcase.pluralize}.vue")
+          File.write(page_path, generate_page_content(name, scope))
+
+          # Gera os componentes
+          components_dir = File.join(frontend_path, "components/#{scope}/#{name.downcase.pluralize}")
+          
+          # Componente principal (index.vue)
+          File.write(File.join(components_dir, "index.vue"), generate_component_content(name, scope))
+          
+          # Componente de criação (create.vue)
+          create_path = File.join(components_dir, "create.vue")
+          File.write(create_path, generate_create_form_content(name, scope))
+          
+          # Componente de edição (edit.vue)
+          edit_path = File.join(components_dir, "edit.vue")
+          File.write(edit_path, generate_edit_form_content(name, scope))
+
+          # Gera o store
+          store_path = File.join(frontend_path, "stores/#{scope}/#{name.downcase.pluralize}.ts")
+          File.write(store_path, generate_store_content(name, scope))
+
+          spinner.success("Frontend #{name} gerado com sucesso no escopo #{scope}!")
+          puts "✓ Componentes gerados:"
+          puts "  - #{page_path}"
+          puts "  - #{components_dir}/index.vue"
+          puts "  - #{components_dir}/create.vue"
+          puts "  - #{components_dir}/edit.vue"
+          puts "  - #{store_path}"
+        else
+          spinner.error("Diretório do Frontend não encontrado em #{frontend_path}")
+        end
+      rescue => e
+        spinner.error("Erro ao gerar frontend: #{e.message}")
+        puts e.backtrace
+      end
+    end
+  end
+end 

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: multiapi_cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Seu Nome
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Uma CLI que integra geradores do Rails e Nuxt para projetos Multiapi
+email:
+- seu.email@exemplo.com
+executables:
+- multiapi
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- exe/multiapi
+- lib/multiapi_cli.rb
+- lib/multiapi_cli/version.rb
+homepage: https://github.com/seu-usuario/multiapi
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: CLI para gerenciar projetos Multiapi
+test_files: []