create-fluxstack 1.5.0 → 1.5.2

package/app/server/routes/example-with-crypto-auth.routes.ts

@@ -1,235 +0,0 @@
-/**
- * Exemplo de uso dos middlewares crypto-auth
- * Demonstra como proteger rotas com autenticação criptográfica
- */
-
-import { Elysia, t } from 'elysia'
-import {
-  cryptoAuthRequired,
-  cryptoAuthAdmin,
-  cryptoAuthPermissions,
-  cryptoAuthOptional,
-  getCryptoAuthUser,
-  isCryptoAuthAdmin
-} from '@/plugins/crypto-auth/server'
-
-// ========================================
-// 1️⃣ ROTAS QUE REQUEREM AUTENTICAÇÃO
-// ========================================
-
-export const protectedRoutes = new Elysia()
-  // ✅ Aplica middleware a TODAS as rotas deste grupo
-  .use(cryptoAuthRequired())
-
-  // Agora TODAS as rotas abaixo requerem autenticação
-  .get('/users/me', ({ request }) => {
-    const user = getCryptoAuthUser(request)!
-
-    return {
-      profile: {
-        publicKey: user.publicKey,
-        isAdmin: user.isAdmin,
-        permissions: user.permissions
-      }
-    }
-  })
-
-  .get('/users', ({ request }) => {
-    const user = getCryptoAuthUser(request)!
-
-    return {
-      users: [
-        { id: 1, name: 'João' },
-        { id: 2, name: 'Maria' }
-      ],
-      requestedBy: user.publicKey.substring(0, 16) + '...'
-    }
-  })
-
-  .post('/posts', ({ request, body }) => {
-    const user = getCryptoAuthUser(request)!
-    const { title, content } = body as { title: string; content: string }
-
-    return {
-      success: true,
-      post: {
-        title,
-        content,
-        author: user.publicKey,
-        createdAt: new Date()
-      }
-    }
-  }, {
-    body: t.Object({
-      title: t.String(),
-      content: t.String()
-    })
-  })
-
-// ========================================
-// 2️⃣ ROTAS QUE REQUEREM ADMIN
-// ========================================
-
-export const adminRoutes = new Elysia()
-  // ✅ Apenas admins podem acessar
-  .use(cryptoAuthAdmin())
-
-  .get('/admin/stats', () => ({
-    totalUsers: 100,
-    totalPosts: 500,
-    systemHealth: 'optimal'
-  }))
-
-  .delete('/admin/users/:id', ({ params, request }) => {
-    const user = getCryptoAuthUser(request)!
-
-    return {
-      success: true,
-      message: `Usuário ${params.id} deletado`,
-      deletedBy: user.publicKey
-    }
-  })
-
-  .post('/admin/broadcast', ({ body }) => ({
-    success: true,
-    message: 'Mensagem enviada para todos os usuários',
-    content: body
-  }), {
-    body: t.Object({
-      message: t.String()
-    })
-  })
-
-// ========================================
-// 3️⃣ ROTAS COM PERMISSÕES ESPECÍFICAS
-// ========================================
-
-export const writeRoutes = new Elysia()
-  // ✅ Requer permissão 'write'
-  .use(cryptoAuthPermissions(['write']))
-
-  .put('/posts/:id', ({ params, body }) => ({
-    success: true,
-    message: `Post ${params.id} atualizado`,
-    data: body
-  }), {
-    body: t.Object({
-      title: t.Optional(t.String()),
-      content: t.Optional(t.String())
-    })
-  })
-
-  .patch('/posts/:id/publish', ({ params }) => ({
-    success: true,
-    message: `Post ${params.id} publicado`
-  }))
-
-// ========================================
-// 4️⃣ ROTAS MISTAS (Opcional)
-// ========================================
-
-export const mixedRoutes = new Elysia()
-  // ✅ Autenticação OPCIONAL - adiciona user se autenticado
-  .use(cryptoAuthOptional())
-
-  // Comportamento diferente se autenticado
-  .get('/posts/:id', ({ request, params }) => {
-    const user = getCryptoAuthUser(request)
-    const isAdmin = isCryptoAuthAdmin(request)
-
-    return {
-      post: {
-        id: params.id,
-        title: 'Título do Post',
-        // Mostra conteúdo completo apenas se autenticado
-        content: user ? 'Conteúdo completo do post...' : 'Prévia...',
-        author: 'João'
-      },
-      viewer: user ? {
-        publicKey: user.publicKey.substring(0, 16) + '...',
-        canEdit: isAdmin,
-        canComment: true
-      } : {
-        canEdit: false,
-        canComment: false
-      }
-    }
-  })
-
-  .get('/posts', ({ request }) => {
-    const user = getCryptoAuthUser(request)
-
-    return {
-      posts: [
-        { id: 1, title: 'Post 1' },
-        { id: 2, title: 'Post 2' }
-      ],
-      authenticated: !!user
-    }
-  })
-
-// ========================================
-// 5️⃣ ROTAS COM VERIFICAÇÃO MANUAL
-// ========================================
-
-export const customRoutes = new Elysia()
-  .use(cryptoAuthRequired())
-
-  .get('/posts/:id/edit', ({ request, params, set }) => {
-    const user = getCryptoAuthUser(request)!
-
-    // Verificação customizada - apenas autor ou admin
-    const post = { id: params.id, authorKey: 'abc123...' } // Buscar do DB
-
-    const canEdit = user.isAdmin || user.publicKey === post.authorKey
-
-    if (!canEdit) {
-      set.status = 403
-      return {
-        error: 'Apenas o autor ou admin podem editar este post'
-      }
-    }
-
-    return {
-      post,
-      canEdit: true
-    }
-  })
-
-// ========================================
-// 6️⃣ COMBINANDO MÚLTIPLOS MIDDLEWARES
-// ========================================
-
-export const combinedRoutes = new Elysia({ prefix: '/api/v1' })
-  // Primeiro grupo - rotas públicas
-  .get('/health', () => ({ status: 'ok' }))
-
-  .get('/posts', () => ({
-    posts: [/* ... */]
-  }))
-
-  // Segundo grupo - rotas protegidas
-  .group('/users', (app) => app
-    .use(cryptoAuthRequired())
-    .get('/', () => ({ users: [] }))
-    .post('/', ({ body }) => ({ created: body }))
-  )
-
-  // Terceiro grupo - rotas admin
-  .group('/admin', (app) => app
-    .use(cryptoAuthAdmin())
-    .get('/stats', () => ({ stats: {} }))
-    .delete('/users/:id', ({ params }) => ({ deleted: params.id }))
-  )
-
-// ========================================
-// 7️⃣ EXPORTAR TODAS AS ROTAS
-// ========================================
-
-export const allExampleRoutes = new Elysia()
-  .use(protectedRoutes)
-  .use(adminRoutes)
-  .use(writeRoutes)
-  .use(mixedRoutes)
-  .use(customRoutes)
-  .use(combinedRoutes)

package/app/server/routes/exemplo-posts.routes.ts

@@ -1,161 +0,0 @@
-/**
- * 🎓 EXEMPLO PRÁTICO: Como criar rotas com Crypto-Auth
- *
- * Este arquivo demonstra como um desenvolvedor cria rotas usando
- * o sistema de autenticação crypto-auth do FluxStack.
- */
-
-import { Elysia, t } from 'elysia'
-import {
-  cryptoAuthRequired,
-  cryptoAuthAdmin,
-  cryptoAuthOptional,
-  getCryptoAuthUser
-} from '@/plugins/crypto-auth/server'
-
-// Mock database (simulação)
-const posts = [
-  { id: 1, title: 'Post Público 1', content: 'Conteúdo aberto', public: true },
-  { id: 2, title: 'Post Público 2', content: 'Conteúdo aberto', public: true }
-]
-
-export const exemploPostsRoutes = new Elysia({ prefix: '/exemplo-posts' })
-
-  // ========================================
-  // 🌐 ROTA PÚBLICA - Qualquer um acessa
-  // ========================================
-  .get('/', () => {
-    return {
-      success: true,
-      message: 'Lista pública de posts',
-      posts: posts.filter(p => p.public)
-    }
-  })
-
-  // ========================================
-  // 🌓 ROTA COM AUTH OPCIONAL
-  // Funciona com ou sem autenticação
-  // ========================================
-  .guard({}, (app) =>
-    app.use(cryptoAuthOptional())
-
-      .get('/:id', ({ request, params }) => {
-        const user = getCryptoAuthUser(request)
-        const isAuthenticated = !!user
-        const post = posts.find(p => p.id === parseInt(params.id))
-
-        if (!post) {
-          return { success: false, error: 'Post não encontrado' }
-        }
-
-        return {
-          success: true,
-          post: {
-            ...post,
-            // ✅ Conteúdo extra apenas para autenticados
-            premiumContent: isAuthenticated
-              ? 'Conteúdo premium exclusivo para usuários autenticados!'
-              : null,
-            viewer: isAuthenticated
-              ? `Autenticado: ${user.publicKey.substring(0, 8)}...`
-              : 'Visitante anônimo'
-          }
-        }
-      })
-  )
-
-  // ========================================
-  // 🔒 ROTAS PROTEGIDAS - Requer autenticação
-  // ========================================
-  .guard({}, (app) =>
-    app.use(cryptoAuthRequired())
-
-      // GET /api/exemplo-posts/meus-posts
-      .get('/meus-posts', ({ request }) => {
-        const user = getCryptoAuthUser(request)!
-
-        return {
-          success: true,
-          message: `Posts criados por você`,
-          user: {
-            publicKey: user.publicKey.substring(0, 16) + '...',
-            isAdmin: user.isAdmin
-          },
-          posts: [
-            {
-              id: 999,
-              title: 'Meu Post Privado',
-              content: 'Só eu posso ver',
-              author: user.publicKey
-            }
-          ]
-        }
-      })
-
-      // POST /api/exemplo-posts/criar
-      .post('/criar', ({ request, body }) => {
-        const user = getCryptoAuthUser(request)!
-        const { title, content } = body as { title: string; content: string }
-
-        const newPost = {
-          id: Date.now(),
-          title,
-          content,
-          author: user.publicKey,
-          createdAt: new Date().toISOString(),
-          public: false
-        }
-
-        posts.push(newPost)
-
-        return {
-          success: true,
-          message: 'Post criado com sucesso!',
-          post: newPost
-        }
-      }, {
-        body: t.Object({
-          title: t.String({ minLength: 3 }),
-          content: t.String({ minLength: 10 })
-        })
-      })
-  )
-
-  // ========================================
-  // 👑 ROTAS ADMIN - Apenas administradores
-  // ========================================
-  .guard({}, (app) =>
-    app.use(cryptoAuthAdmin())
-
-      // GET /api/exemplo-posts/admin/todos
-      .get('/admin/todos', ({ request }) => {
-        const user = getCryptoAuthUser(request)!
-
-        return {
-          success: true,
-          message: 'Painel administrativo',
-          admin: user.publicKey.substring(0, 8) + '...',
-          totalPosts: posts.length,
-          posts: posts // Admin vê tudo
-        }
-      })
-
-      // DELETE /api/exemplo-posts/admin/:id
-      .delete('/admin/:id', ({ request, params }) => {
-        const user = getCryptoAuthUser(request)!
-        const postIndex = posts.findIndex(p => p.id === parseInt(params.id))
-
-        if (postIndex === -1) {
-          return { success: false, error: 'Post não encontrado' }
-        }
-
-        const deletedPost = posts.splice(postIndex, 1)[0]
-
-        return {
-          success: true,
-          message: `Post "${deletedPost.title}" deletado pelo admin`,
-          deletedBy: user.publicKey.substring(0, 8) + '...',
-          deletedPost
-        }
-      })
-  )

package/core/plugins/module-resolver.ts

@@ -1,216 +0,0 @@
-/**
- * Module Resolver para Plugins
- * Implementa resolução em cascata: plugin local → projeto principal
- */
-
-import { existsSync } from 'fs'
-import { join, resolve } from 'path'
-import type { Logger } from '../utils/logger'
-
-export interface ModuleResolverConfig {
-  projectRoot: string
-  logger?: Logger
-}
-
-export class PluginModuleResolver {
-  private config: ModuleResolverConfig
-  private logger?: Logger
-  private resolveCache: Map<string, string> = new Map()
-
-  constructor(config: ModuleResolverConfig) {
-    this.config = config
-    this.logger = config.logger
-  }
-
-  /**
-   * Resolve um módulo com estratégia em cascata:
-   * 1. node_modules local do plugin
-   * 2. node_modules do projeto principal
-   */
-  resolveModule(moduleName: string, pluginPath: string): string | null {
-    const cacheKey = `${pluginPath}::${moduleName}`
-
-    // Verificar cache
-    if (this.resolveCache.has(cacheKey)) {
-      return this.resolveCache.get(cacheKey)!
-    }
-
-    this.logger?.debug(`Resolvendo módulo '${moduleName}' para plugin em '${pluginPath}'`)
-
-    // 1. Tentar no node_modules local do plugin
-    const localPath = this.tryResolveLocal(moduleName, pluginPath)
-    if (localPath) {
-      this.logger?.debug(`✅ Módulo '${moduleName}' encontrado localmente: ${localPath}`)
-      this.resolveCache.set(cacheKey, localPath)
-      return localPath
-    }
-
-    // 2. Tentar no node_modules do projeto principal
-    const projectPath = this.tryResolveProject(moduleName)
-    if (projectPath) {
-      this.logger?.debug(`✅ Módulo '${moduleName}' encontrado no projeto: ${projectPath}`)
-      this.resolveCache.set(cacheKey, projectPath)
-      return projectPath
-    }
-
-    this.logger?.warn(`❌ Módulo '${moduleName}' não encontrado em nenhum contexto`)
-    return null
-  }
-
-  /**
-   * Tenta resolver no node_modules local do plugin
-   */
-  private tryResolveLocal(moduleName: string, pluginPath: string): string | null {
-    const pluginDir = resolve(pluginPath)
-    const localNodeModules = join(pluginDir, 'node_modules', moduleName)
-
-    if (existsSync(localNodeModules)) {
-      // Verificar se tem package.json para pegar o entry point
-      const packageJsonPath = join(localNodeModules, 'package.json')
-      if (existsSync(packageJsonPath)) {
-        try {
-          const pkg = require(packageJsonPath)
-          const entry = pkg.module || pkg.main || 'index.js'
-          const entryPath = join(localNodeModules, entry)
-
-          if (existsSync(entryPath)) {
-            return entryPath
-          }
-        } catch (error) {
-          this.logger?.debug(`Erro ao ler package.json de '${moduleName}'`, { error })
-        }
-      }
-
-      // Fallback: tentar index.js/index.ts
-      const indexJs = join(localNodeModules, 'index.js')
-      const indexTs = join(localNodeModules, 'index.ts')
-
-      if (existsSync(indexJs)) return indexJs
-      if (existsSync(indexTs)) return indexTs
-
-      return localNodeModules
-    }
-
-    return null
-  }
-
-  /**
-   * Tenta resolver no node_modules do projeto principal
-   */
-  private tryResolveProject(moduleName: string): string | null {
-    const projectNodeModules = join(this.config.projectRoot, 'node_modules', moduleName)
-
-    if (existsSync(projectNodeModules)) {
-      // Verificar se tem package.json para pegar o entry point
-      const packageJsonPath = join(projectNodeModules, 'package.json')
-      if (existsSync(packageJsonPath)) {
-        try {
-          const pkg = require(packageJsonPath)
-          const entry = pkg.module || pkg.main || 'index.js'
-          const entryPath = join(projectNodeModules, entry)
-
-          if (existsSync(entryPath)) {
-            return entryPath
-          }
-        } catch (error) {
-          this.logger?.debug(`Erro ao ler package.json de '${moduleName}'`, { error })
-        }
-      }
-
-      // Fallback: tentar index.js/index.ts
-      const indexJs = join(projectNodeModules, 'index.js')
-      const indexTs = join(projectNodeModules, 'index.ts')
-
-      if (existsSync(indexJs)) return indexJs
-      if (existsSync(indexTs)) return indexTs
-
-      return projectNodeModules
-    }
-
-    return null
-  }
-
-  /**
-   * Resolve sub-paths (ex: @noble/curves/ed25519)
-   */
-  resolveSubpath(moduleName: string, subpath: string, pluginPath: string): string | null {
-    const fullModule = `${moduleName}/${subpath}`
-    const cacheKey = `${pluginPath}::${fullModule}`
-
-    // Verificar cache
-    if (this.resolveCache.has(cacheKey)) {
-      return this.resolveCache.get(cacheKey)!
-    }
-
-    this.logger?.debug(`Resolvendo subpath '${fullModule}' para plugin em '${pluginPath}'`)
-
-    // 1. Tentar no node_modules local do plugin
-    const pluginDir = resolve(pluginPath)
-    const localPath = join(pluginDir, 'node_modules', fullModule)
-
-    if (this.existsWithExtension(localPath)) {
-      const resolvedLocal = this.findFileWithExtension(localPath)
-      if (resolvedLocal) {
-        this.logger?.debug(`✅ Subpath '${fullModule}' encontrado localmente: ${resolvedLocal}`)
-        this.resolveCache.set(cacheKey, resolvedLocal)
-        return resolvedLocal
-      }
-    }
-
-    // 2. Tentar no node_modules do projeto principal
-    const projectPath = join(this.config.projectRoot, 'node_modules', fullModule)
-
-    if (this.existsWithExtension(projectPath)) {
-      const resolvedProject = this.findFileWithExtension(projectPath)
-      if (resolvedProject) {
-        this.logger?.debug(`✅ Subpath '${fullModule}' encontrado no projeto: ${resolvedProject}`)
-        this.resolveCache.set(cacheKey, resolvedProject)
-        return resolvedProject
-      }
-    }
-
-    this.logger?.warn(`❌ Subpath '${fullModule}' não encontrado em nenhum contexto`)
-    return null
-  }
-
-  /**
-   * Verifica se arquivo existe com alguma extensão comum
-   */
-  private existsWithExtension(basePath: string): boolean {
-    const extensions = ['', '.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx', '/index.js', '/index.ts']
-    return extensions.some(ext => existsSync(basePath + ext))
-  }
-
-  /**
-   * Encontra arquivo com extensão
-   */
-  private findFileWithExtension(basePath: string): string | null {
-    const extensions = ['', '.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx', '/index.js', '/index.ts']
-
-    for (const ext of extensions) {
-      const fullPath = basePath + ext
-      if (existsSync(fullPath)) {
-        return fullPath
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Limpar cache
-   */
-  clearCache(): void {
-    this.resolveCache.clear()
-  }
-
-  /**
-   * Obter estatísticas
-   */
-  getStats() {
-    return {
-      cachedModules: this.resolveCache.size,
-      projectRoot: this.config.projectRoot
-    }
-  }
-}