@semacode/cli 1.5.30 → 1.5.31

package/dist/init/templates.js

@@ -0,0 +1,660 @@
+// Templates para sema init --template
+// Contrato: cli_init_templates.sema
+const templateCrudSimples = (moduloNome) => `module ${moduloNome} {
+  entity Item {
+    fields {
+      id: Id
+      nome: Texto
+      descricao: Texto
+      ativo: Booleano
+      criado_em: Timestamp
+    }
+  }
+
+  task criar_item {
+    input {
+      nome: Texto required
+      descricao: Texto optional
+    }
+    output {
+      item: Item
+    }
+    rules {
+      nome deve_ser preenchido
+    }
+    effects {
+      persistencia Item
+      auditoria item_criado
+    }
+    guarantees {
+      item existe
+    }
+    tests {
+      caso "cria item basico" {
+        given {
+          nome: "Novo Item"
+        }
+        expect {
+          sucesso: verdadeiro
+        }
+      }
+    }
+  }
+
+  task listar_itens {
+    input {
+      ativo: Booleano optional
+      pagina: Inteiro optional
+      limite: Inteiro optional
+    }
+    output {
+      itens: Lista<Item>
+      total: Inteiro
+    }
+    effects {
+      consulta Item
+    }
+    guarantees {
+      itens existe
+    }
+  }
+
+  route itens {
+    metodo: POST
+    caminho: /itens
+    task: criar_item
+    finalidade: criar_novo_item
+    input {
+      nome: Texto
+      descricao: Texto
+    }
+    output {
+      item: Item
+    }
+    auth {
+      modo: obrigatorio
+    }
+    authz {
+      escopo: ${moduloNome}.criar
+    }
+    audit {
+      evento: ${moduloNome}.item.criado
+      ator: auth.usuario
+      retencao: "90d"
+    }
+  }
+}`;
+const templateAuthCompleto = (moduloNome) => `module ${moduloNome} {
+  entity Usuario {
+    fields {
+      id: Id
+      email: Email
+      senha_hash: Texto
+      papel: Texto
+      ativo: Booleano
+      ultimo_login: Timestamp
+    }
+  }
+
+  task autenticar_usuario {
+    input {
+      email: Email required
+      senha: Texto required
+    }
+    output {
+      token: Texto
+      usuario: Usuario
+      expiracao: Timestamp
+    }
+    rules {
+      email deve_ser email_valido
+      senha deve_ter tamanho >= 8
+    }
+    effects {
+      consulta Usuario
+      auditoria login_tentativa
+    }
+    forbidden {
+      expor_senha_em_log
+      retornar_senha_hash
+      permitir_credencial_inativa
+    }
+    guarantees {
+      token existe
+      expiracao > agora
+    }
+    error {
+      credenciais_invalidas: "Email ou senha incorretos."
+      conta_inativa: "Conta desativada. Contate o administrador."
+      senha_fraca: "Senha nao atende aos requisitos minimos."
+    }
+    tests {
+      caso "login com sucesso" {
+        given {
+          email: "user@exemplo.com"
+          senha: "senha123"
+        }
+        expect {
+          sucesso: verdadeiro
+          token existe
+        }
+      }
+    }
+  }
+
+  task registrar_usuario {
+    input {
+      email: Email required
+      senha: Texto required
+      confirmar_senha: Texto required
+    }
+    output {
+      usuario: Usuario
+    }
+    rules {
+      email deve_ser email_valido
+      email deve_ser unico em Usuario.email
+      senha deve_ter tamanho >= 8
+      senha deve_coincidir com confirmar_senha
+    }
+    effects {
+      persistencia Usuario
+      evento usuario_registrado
+      auditoria cadastro_novo
+    }
+    forbidden {
+      armazenar_senha_texto_plano
+      permitir_email_duplicado
+    }
+    guarantees {
+      usuario existe
+      usuario.senha_hash nao_eh_texto_plano
+    }
+    error {
+      email_duplicado: "Ja existe conta com este email."
+      senha_fraca: "Senha deve ter pelo menos 8 caracteres."
+      senhas_diferentes: "As senhas nao coincidem."
+    }
+  }
+}`;
+const templateApiRest = (moduloNome) => `module ${moduloNome} {
+  docs {
+    resumo: "API REST completa com CRUD, autenticacao e paginacao."
+    versao: "1.0.0"
+  }
+
+  entity Recurso {
+    fields {
+      id: Id
+      titulo: Texto
+      conteudo: Texto
+      status: Texto
+      criado_por: Id
+      criado_em: Timestamp
+      atualizado_em: Timestamp
+    }
+  }
+
+  task criar_recurso {
+    input {
+      titulo: Texto required
+      conteudo: Texto required
+    }
+    output {
+      recurso: Recurso
+    }
+    rules {
+      titulo deve_ser preenchido
+      conteudo deve_ser preenchido
+    }
+    effects {
+      persistencia Recurso
+      auditoria recurso_criado
+    }
+    auth {
+      modo: obrigatorio
+    }
+    authz {
+      escopo: ${moduloNome}.escrever
+      papeis: [admin, editor]
+    }
+    dados {
+      input {
+        titulo: publico
+        conteudo: interno
+      }
+    }
+    audit {
+      evento: ${moduloNome}.recurso.criado
+      ator: auth.usuario
+      retencao: "90d"
+    }
+    guarantees {
+      recurso existe
+      recurso.criado_por == auth.usuario_id
+    }
+  }
+
+  task obter_recurso {
+    input {
+      id: Id required
+    }
+    output {
+      recurso: Recurso
+    }
+    rules {
+      id deve_ser valido
+    }
+    effects {
+      consulta Recurso
+    }
+    auth {
+      modo: opcional
+    }
+    authz {
+      escopo: ${moduloNome}.ler
+    }
+    guarantees {
+      recurso existe
+    }
+    error {
+      nao_encontrado: "Recurso nao encontrado."
+    }
+  }
+
+  task listar_recursos {
+    input {
+      status: Texto optional
+      pagina: Inteiro optional
+      limite: Inteiro optional
+      ordenar_por: Texto optional
+    }
+    output {
+      recursos: Lista<Recurso>
+      total: Inteiro
+      pagina: Inteiro
+      total_paginas: Inteiro
+    }
+    rules {
+      limite quando preenchido deve_ser <= 100
+      pagina quando preenchido deve_ser >= 1
+    }
+    effects {
+      consulta Recurso
+    }
+    auth {
+      modo: anonimo
+    }
+    guarantees {
+      recursos existe
+    }
+  }
+
+  task atualizar_recurso {
+    input {
+      id: Id required
+      titulo: Texto optional
+      conteudo: Texto optional
+      status: Texto optional
+    }
+    output {
+      recurso: Recurso
+    }
+    rules {
+      id deve_ser valido
+      pelo_menos_um_campo_preenchido
+    }
+    effects {
+      persistencia Recurso
+      auditoria recurso_atualizado
+    }
+    auth {
+      modo: obrigatorio
+    }
+    authz {
+      escopo: ${moduloNome}.escrever
+      regra: recurso.criado_por == auth.usuario_id ou auth.papel == admin
+    }
+    guarantees {
+      recurso existe
+      atualizado_em atualizado
+    }
+    error {
+      nao_encontrado: "Recurso nao encontrado."
+      sem_permissao: "Voce nao tem permissao para editar este recurso."
+    }
+  }
+
+  task excluir_recurso {
+    input {
+      id: Id required
+      confirmar: Booleano required
+    }
+    output {
+      excluido: Booleano
+    }
+    rules {
+      id deve_ser valido
+      confirmar == verdadeiro
+    }
+    effects {
+      persistencia Recurso criticidade = alta
+      auditoria recurso_excluido criticidade = alta
+    }
+    forbidden {
+      excluir_sem_confirmacao
+      cascade_delete_sem_backup
+    }
+    auth {
+      modo: obrigatorio
+    }
+    authz {
+      escopo: ${moduloNome}.deletar
+      regra: auth.papel == admin ou recurso.criado_por == auth.usuario_id
+    }
+    guarantees {
+      excluido == verdadeiro
+    }
+    error {
+      nao_encontrado: "Recurso nao encontrado."
+      sem_confirmacao: "Exclusao requer confirmacao explicita."
+    }
+  }
+
+  route recursos_criar {
+    metodo: POST
+    caminho: /recursos
+    task: criar_recurso
+    finalidade: criar_recurso_api
+  }
+
+  route recursos_listar {
+    metodo: GET
+    caminho: /recursos
+    task: listar_recursos
+    finalidade: listar_recursos_api
+  }
+
+  route recursos_obter {
+    metodo: GET
+    caminho: /recursos/:id
+    task: obter_recurso
+    finalidade: obter_recurso_api
+  }
+
+  route recursos_atualizar {
+    metodo: PUT
+    caminho: /recursos/:id
+    task: atualizar_recurso
+    finalidade: atualizar_recurso_api
+  }
+
+  route recursos_excluir {
+    metodo: DELETE
+    caminho: /recursos/:id
+    task: excluir_recurso
+    finalidade: excluir_recurso_api
+  }
+}`;
+const templateWorkflow = (moduloNome) => `module ${moduloNome} {
+  docs {
+    resumo: "Workflow de automacao com trigger, acoes e condicoes."
+  }
+
+  entity Workflow {
+    fields {
+      id: Id
+      nome: Texto
+      ativo: Booleano
+      trigger_tipo: Texto
+      trigger_config: Texto
+      acoes: Lista<Texto>
+      criado_em: Timestamp
+    }
+  }
+
+  task executar_workflow {
+    input {
+      workflow_id: Id required
+      payload: Texto required
+      contexto: Mapa<Texto, Texto> optional
+    }
+    output {
+      execucao_id: Id
+      resultado: Texto
+      status: Texto
+      duracao_ms: Inteiro
+    }
+    rules {
+      workflow_id deve_ser valido
+      payload deve_ser json_valido
+    }
+    effects {
+      consulta Workflow
+      consulta workflow_runtime
+      persistencia execucao_log
+      auditoria workflow_executado
+    }
+    execucao {
+      timeout: "30s"
+      retry: "ate 3 tentativas"
+      idempotencia: verdadeiro
+    }
+    guarantees {
+      execucao_id existe
+      status em ["sucesso", "falha", "timeout"]
+    }
+    error {
+      workflow_nao_encontrado: "Workflow nao encontrado."
+      workflow_inativo: "Workflow esta desativado."
+      execucao_timeout: "Workflow excedeu tempo limite."
+    }
+  }
+
+  flow orquestracao_workflow {
+    workflow_id: Id
+    payload: Texto
+    etapa validar usa executar_workflow com workflow_id = workflow_id, payload = payload em_sucesso processar em_erro registrar_falha
+    etapa processar usa processar_resultado com execucao_id = validar.execucao_id depende_de validar
+    etapa registrar_falha usa log_erro_workflow com workflow_id = workflow_id, erro = validar.error depende_de validar
+  }
+}`;
+const templatePedido = (moduloNome) => `module ${moduloNome} {
+  entity Pedido {
+    fields {
+      id: Id
+      cliente_id: Id
+      itens: Lista<Texto>
+      valor_total: Decimal
+      status: Texto
+      criado_em: Timestamp
+    }
+  }
+
+  task criar_pedido {
+    input {
+      cliente_id: Id required
+      itens: Lista<Texto> required
+    }
+    output {
+      pedido: Pedido
+    }
+    rules {
+      cliente_id deve_ser valido
+      itens deve_ser nao_vazio
+    }
+    effects {
+      persistencia Pedido
+      evento pedido_criado
+    }
+    guarantees {
+      pedido existe
+      pedido.status == "pendente"
+    }
+  }
+}`;
+const templateUsuario = (moduloNome) => `module ${moduloNome} {
+  entity Usuario {
+    fields {
+      id: Id
+      nome: Texto
+      email: Email
+      ativo: Booleano
+    }
+  }
+
+  task criar_usuario {
+    input {
+      nome: Texto required
+      email: Email required
+    }
+    output {
+      usuario: Usuario
+    }
+    rules {
+      nome deve_ser preenchido
+      email deve_ser email_valido
+      email deve_ser unico em Usuario.email
+    }
+    effects {
+      persistencia Usuario
+      evento usuario_criado
+      auditoria cadastro_usuario
+    }
+    guarantees {
+      usuario existe
+      persistencia concluida
+    }
+    error {
+      email_duplicado: "Ja existe usuario com este email."
+      entrada_invalida: "Os dados informados nao atendem as regras."
+    }
+    tests {
+      caso "cria usuario valido" {
+        given {
+          nome: "Ana"
+          email: "ana@empresa.com"
+        }
+        expect {
+          sucesso: verdadeiro
+        }
+      }
+    }
+  }
+}`;
+const templateUpload = (moduloNome) => `module ${moduloNome} {
+  entity Arquivo {
+    fields {
+      id: Id
+      nome_original: Texto
+      mime_type: Texto
+      tamanho_bytes: Inteiro
+      url: Texto
+      upload_por: Id
+      criado_em: Timestamp
+    }
+  }
+
+  task upload_arquivo {
+    input {
+      arquivo_binario: Texto required
+      nome_original: Texto required
+      mime_type: Texto required
+    }
+    output {
+      arquivo: Arquivo
+      url_acesso: Texto
+    }
+    rules {
+      tamanho_bytes deve_ser <= 10485760  // 10MB
+      mime_type em ["image/jpeg", "image/png", "application/pdf", "text/plain"]
+    }
+    effects {
+      persistencia Arquivo
+      storage.write arquivo_binario
+      auditoria arquivo_uploadado
+    }
+    forbidden {
+      executar_arquivo_uploadado
+      armazenar_exe_ou_script
+      permitir_upload_anonimo_sem_rate_limit
+    }
+    guarantees {
+      arquivo existe
+      url_acesso existe
+    }
+    error {
+      arquivo_muito_grande: "Arquivo excede 10MB."
+      tipo_nao_permitido: "Tipo de arquivo nao permitido."
+    }
+  }
+}`;
+export const templatesDisponiveis = {
+    "crud-simples": {
+        nome: "crud-simples",
+        categoria: "basico",
+        descricao: "CRUD simples com entity, tasks basicas e route POST",
+        linhasBase: 45,
+        camposEditaveis: ["nome_modulo", "nome_entity", "nome_task"],
+        conteudo: templateCrudSimples
+    },
+    "auth-completo": {
+        nome: "auth-completo",
+        categoria: "seguranca",
+        descricao: "Autenticacao completa com login, registro, tokens e senha",
+        linhasBase: 60,
+        camposEditaveis: ["nome_modulo", "escopos_authz"],
+        conteudo: templateAuthCompleto
+    },
+    "api-rest": {
+        nome: "api-rest",
+        categoria: "api",
+        descricao: "API REST completa com CRUD, paginacao, autenticacao e 5 routes",
+        linhasBase: 180,
+        camposEditaveis: ["nome_modulo", "nome_entity", "campos_entity"],
+        conteudo: templateApiRest
+    },
+    "workflow": {
+        nome: "workflow",
+        categoria: "automation",
+        descricao: "Workflow de automacao com trigger, execucao e flow",
+        linhasBase: 60,
+        camposEditaveis: ["nome_modulo", "triggers", "acoes"],
+        conteudo: templateWorkflow
+    },
+    "pedido": {
+        nome: "pedido",
+        categoria: "ecommerce",
+        descricao: "Template simplificado de pedido para ecommerce",
+        linhasBase: 30,
+        camposEditaveis: ["nome_modulo", "campos_pedido"],
+        conteudo: templatePedido
+    },
+    "usuario": {
+        nome: "usuario",
+        categoria: "cadastro",
+        descricao: "Cadastro de usuario com email unico e validacoes",
+        linhasBase: 40,
+        camposEditaveis: ["nome_modulo", "campos_usuario"],
+        conteudo: templateUsuario
+    },
+    "upload": {
+        nome: "upload",
+        categoria: "arquivos",
+        descricao: "Upload de arquivos com validacao de tipo e tamanho",
+        linhasBase: 50,
+        camposEditaveis: ["nome_modulo", "tipos_permitidos", "tamanho_maximo"],
+        conteudo: templateUpload
+    }
+};
+export function listarTemplates(categoriaFiltro) {
+    const templates = Object.values(templatesDisponiveis);
+    if (categoriaFiltro) {
+        return templates.filter(t => t.categoria === categoriaFiltro);
+    }
+    return templates;
+}
+export function obterTemplate(nome) {
+    return templatesDisponiveis[nome] || null;
+}
+//# sourceMappingURL=templates.js.map

package/dist/init/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../src/init/templates.ts"],"names":[],"mappings":"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"}

package/dist/sync/index.d.ts

@@ -0,0 +1,24 @@
+export interface MapeamentoTipo {
+    semaTipo: string;
+    prismaTipo: string;
+    atributosPrisma: string[];
+}
+export declare function mapearTiposSemaPrisma(): {
+    mapeamentos: MapeamentoTipo[];
+    cobertura: number;
+};
+export declare function gerarSchemaPrisma(pastaContratos: string, saidaSchema: string, datasourceProvider?: string): Promise<{
+    schemaGerado: string;
+    modelsGerados: number;
+    enumsGerados: number;
+}>;
+export declare function importarSchemaPrisma(caminhoSchema: string, pastaSaida: string, nomeModulo: string): Promise<{
+    contratosGerados: string[];
+    entitiesCriadas: number;
+}>;
+export declare function compararDivergencias(pastaContratos: string, caminhoSchema: string): Promise<{
+    divergencias: string[];
+    total: number;
+    breaking: number;
+}>;
+export declare function comandoSyncPrisma(args: string[]): Promise<void>;