nestforge-generator 0.2.0 → 0.3.0

package/templates/prisma/TESTING.md

@@ -8,7 +8,7 @@ This guide validates a project generated from the NestForge Prisma template.
 
 * Node.js 20 or later
 * npm 10 or later
-* Docker when testing PostgreSQL, MySQL, Redis, or Mailpit
+* Docker when testing PostgreSQL, MySQL, MongoDB, Redis, or Mailpit
 
 SQLite can be tested without Docker.
 
@@ -30,10 +30,18 @@ npm run prisma:generate
 
 ## Apply the development schema
 
+For PostgreSQL, MySQL, or SQLite:
+
 ```bash
 npm run prisma:migrate -- --name init
 ```
 
+For MongoDB:
+
+```bash
+npm run prisma:push
+```
+
 Run the seed when the generated project includes password authentication:
 
 ```bash
@@ -67,7 +75,7 @@ Unit tests mock Prisma and Redis, so they do not require real services.
 npm run test:e2e
 ```
 
-The `pretest:e2e` script runs `prisma migrate deploy` with `.env.test` before the suite starts.
+The `pretest:e2e` script runs `prisma migrate deploy` for relational databases or `prisma db push` for MongoDB with `.env.test` before the suite starts.
 
 Depending on the generated authentication strategy, the suite may cover:
 
@@ -110,11 +118,25 @@ npm test
 npm run test:e2e
 ```
 
+### MongoDB
+
+MongoDB must run as a replica set because Prisma uses transactions for nested writes. The generated Docker Compose configures a single-node replica set:
+
+```bash
+docker compose up -d mongodb
+npm run prisma:push
+npm run build
+npm test
+npm run test:e2e
+```
+
+Use different database names in `.env` and `.env.test`, such as `nestforge` and `nestforge_test`.
+
 ## Final checklist
 
 * [ ] Dependencies install successfully
 * [ ] Prisma Client is generated
-* [ ] Migrations are applied
+* [ ] Migrations are applied, or the MongoDB schema is pushed
 * [ ] Seed runs when applicable
 * [ ] Build passes
 * [ ] Lint passes

package/templates/prisma/TESTING.pt-BR.md

@@ -8,7 +8,7 @@ Este guia valida um projeto gerado a partir do template Prisma do NestForge.
 
 * Node.js 20 ou superior
 * npm 10 ou superior
-* Docker para testar PostgreSQL, MySQL, Redis ou Mailpit
+* Docker para testar PostgreSQL, MySQL, MongoDB, Redis ou Mailpit
 
 SQLite pode ser testado sem Docker.
 
@@ -30,10 +30,18 @@ npm run prisma:generate
 
 ## Aplicar o schema de desenvolvimento
 
+Para PostgreSQL, MySQL ou SQLite:
+
 ```bash
 npm run prisma:migrate -- --name init
 ```
 
+Para MongoDB:
+
+```bash
+npm run prisma:push
+```
+
 Execute o seed quando o projeto gerado incluir autenticação por senha:
 
 ```bash
@@ -67,7 +75,7 @@ Os testes unitários simulam Prisma e Redis, portanto não exigem serviços reai
 npm run test:e2e
 ```
 
-O script `pretest:e2e` executa `prisma migrate deploy` com `.env.test` antes do início da suíte.
+O script `pretest:e2e` executa `prisma migrate deploy` nos bancos relacionais ou `prisma db push` no MongoDB com `.env.test` antes do início da suíte.
 
 Dependendo da estratégia de autenticação gerada, a suíte pode cobrir:
 
@@ -110,11 +118,25 @@ npm test
 npm run test:e2e
 ```
 
+### MongoDB
+
+O MongoDB deve funcionar como replica set porque o Prisma usa transações em escritas aninhadas. O Docker Compose gerado configura um replica set de nó único:
+
+```bash
+docker compose up -d mongodb
+npm run prisma:push
+npm run build
+npm test
+npm run test:e2e
+```
+
+Use nomes de banco diferentes em `.env` e `.env.test`, como `nestforge` e `nestforge_test`.
+
 ## Checklist final
 
 * [ ] As dependências são instaladas corretamente
 * [ ] O Prisma Client é gerado
-* [ ] As migrations são aplicadas
+* [ ] As migrations são aplicadas ou o schema MongoDB é enviado
 * [ ] O seed executa quando aplicável
 * [ ] O build passa
 * [ ] O lint passa

package/templates/prisma/docker-compose.yml

@@ -10,6 +10,10 @@ services:
       - "3000:3000"
     env_file:
       - .env
+    # nestforge:feature:database:mongodb
+    environment:
+      DATABASE_URL: mongodb://mongodb:27017/nestforge?replicaSet=rs0
+    # nestforge:feature:database:mongodb:end
     depends_on:
       # nestforge:feature:database:postgres
       - postgres
@@ -17,6 +21,9 @@ services:
       # nestforge:feature:database:mysql
       - mysql
       # nestforge:feature:database:mysql:end
+      # nestforge:feature:database:mongodb
+      - mongodb
+      # nestforge:feature:database:mongodb:end
       - redis
     volumes:
       - ./src:/app/src
@@ -53,6 +60,23 @@ services:
       - mysql_data:/var/lib/mysql
   # nestforge:feature:database:mysql:end
 
+  # nestforge:feature:database:mongodb
+  mongodb:
+    image: mongo:8
+    container_name: nestforge-mongodb
+    restart: unless-stopped
+    command: ["mongod", "--replSet", "rs0", "--bind_ip_all"]
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongodb_data:/data/db
+    healthcheck:
+      test: ["CMD-SHELL", "mongosh --quiet --eval \"try { rs.status().ok } catch (error) { rs.initiate({_id: 'rs0', members: [{_id: 0, host: 'mongodb:27017'}]}).ok }\" | grep 1"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+  # nestforge:feature:database:mongodb:end
+
   redis:
     image: redis:7-alpine
     container_name: nestforge-redis
@@ -75,4 +99,8 @@ volumes:
   # nestforge:feature:database:mysql
 volumes:
   mysql_data:
-  # nestforge:feature:database:mysql:end
+  # nestforge:feature:database:mysql:end
+  # nestforge:feature:database:mongodb
+volumes:
+  mongodb_data:
+  # nestforge:feature:database:mongodb:end

package/templates/prisma/docs/adding-a-module.md

@@ -1,230 +1,246 @@
-# Como adicionar um novo módulo
-
-Este guia mostra o passo a passo pra adicionar um recurso novo seguindo as convenções do NestForge, usando um módulo `posts` (posts de blog) como exemplo. Adapte os nomes pro seu caso.
-
-## 1. Adicione o model no Prisma
-
-Em `prisma/schema.prisma`:
-
-```prisma
-model Post {
-  id        String   @id @default(uuid())
-  title     String
-  content   String
-  authorId  String
-  author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  @@map("posts")
-}
-```
-
-Não esqueça de adicionar a relação inversa no `model User`:
-
-```prisma
-posts Post[]
-```
-
-Gere a migration:
-
-```bash
-npx prisma migrate dev --name add_posts
-```
-
-## 2. Crie a estrutura de pastas
-
-```
-src/posts/
-├── dto/
-│   ├── create-post.dto.ts
-│   └── update-post.dto.ts
-├── entities/
-│   └── post.entity.ts
-├── posts.controller.ts
-├── posts.service.ts
-└── posts.module.ts
-```
-
-## 3. DTOs com Zod
-
-`src/posts/dto/create-post.dto.ts`:
-
-```ts
-import { z } from 'zod';
-import { createZodDto } from 'nestjs-zod';
-
-export const createPostSchema = z.object({
-  title: z.string().min(3).describe('Título do post'),
-  content: z.string().min(10).describe('Conteúdo do post'),
-});
-
-export class CreatePostDto extends createZodDto(createPostSchema) {}
-```
-
-`src/posts/dto/update-post.dto.ts`:
-
-```ts
-import { createZodDto } from 'nestjs-zod';
-import { createPostSchema } from './create-post.dto';
-
-export const updatePostSchema = createPostSchema.partial();
-
-export class UpdatePostDto extends createZodDto(updatePostSchema) {}
-```
-
-## 4. Entity (o que a API expõe)
-
-`src/posts/entities/post.entity.ts` — mesmo se não houver nada sensível pra esconder agora, criar a entity já deixa o padrão pronto pra quando houver:
-
-```ts
-export class PostEntity {
-  id: string;
-  title: string;
-  content: string;
-  authorId: string;
-  createdAt: Date;
-  updatedAt: Date;
-
-  constructor(partial: Partial<PostEntity>) {
-    Object.assign(this, partial);
-  }
-}
-```
-
-## 5. Service (regra de negócio)
-
-`src/posts/posts.service.ts`:
-
-```ts
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { PrismaService } from '../database/prisma.service';
-import { CreatePostDto } from './dto/create-post.dto';
-import { UpdatePostDto } from './dto/update-post.dto';
-import { PostEntity } from './entities/post.entity';
-
-@Injectable()
-export class PostsService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async create(authorId: string, dto: CreatePostDto) {
-    const post = await this.prisma.post.create({ data: { ...dto, authorId } });
-    return new PostEntity(post);
-  }
-
-  async findOne(id: string) {
-    const post = await this.prisma.post.findUnique({ where: { id } });
-    if (!post) throw new NotFoundException('Post não encontrado');
-    return new PostEntity(post);
-  }
-
-  async update(id: string, dto: UpdatePostDto) {
-    await this.findOne(id);
-    const post = await this.prisma.post.update({ where: { id }, data: dto });
-    return new PostEntity(post);
-  }
-
-  async remove(id: string) {
-    await this.findOne(id);
-    await this.prisma.post.delete({ where: { id } });
-    return { message: 'Post removido com sucesso' };
-  }
-}
-```
-
-## 6. Controller (guards + permissions)
-
-Se o recurso precisa de controle de acesso, adicione a permission em `src/common/constants/permissions.ts` e no mapeamento `src/common/constants/role-permissions.ts` antes de usar:
-
-```ts
-// permissions.ts
-export enum Permission {
-  // ...existentes
-  PostCreate = 'post:create',
-  PostDelete = 'post:delete',
-}
-```
-
-`src/posts/posts.controller.ts`:
-
-```ts
-import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
-import { PostsService } from './posts.service';
-import { CreatePostDto } from './dto/create-post.dto';
-import { UpdatePostDto } from './dto/update-post.dto';
-import { Permissions } from '../common/decorators/permissions.decorator';
-import { Permission } from '../common/constants/permissions';
-import { CurrentUser } from '../common/decorators/current-user.decorator';
-
-@ApiTags('posts')
-@ApiBearerAuth()
-@Controller('posts')
-export class PostsController {
-  constructor(private readonly postsService: PostsService) {}
-
-  @Post()
-  @Permissions(Permission.PostCreate)
-  create(@CurrentUser() user: { id: string }, @Body() dto: CreatePostDto) {
-    return this.postsService.create(user.id, dto);
-  }
-
-  @Get(':id')
-  findOne(@Param('id') id: string) {
-    return this.postsService.findOne(id);
-  }
-
-  @Patch(':id')
-  update(@Param('id') id: string, @Body() dto: UpdatePostDto) {
-    return this.postsService.update(id, dto);
-  }
-
-  @Delete(':id')
-  @Permissions(Permission.PostDelete)
-  remove(@Param('id') id: string) {
-    return this.postsService.remove(id);
-  }
-}
-```
-
-## 7. Module
-
-`src/posts/posts.module.ts`:
-
-```ts
-import { Module } from '@nestjs/common';
-import { PostsService } from './posts.service';
-import { PostsController } from './posts.controller';
-
-@Module({
-  controllers: [PostsController],
-  providers: [PostsService],
-  exports: [PostsService],
-})
-export class PostsModule {}
-```
-
-Registre no `src/app.module.ts` (dentro do array `imports`):
-
-```ts
-import { PostsModule } from './posts/posts.module';
-// ...
-PostsModule,
-```
-
-## 8. Testes
-
-- **Unitário** (`src/posts/posts.service.spec.ts`): mocke o `PrismaService` como em `src/users/users.service.spec.ts` — sem banco real.
-- **E2e** (`test/posts.e2e-spec.ts`): use os helpers de `test/utils/e2e-setup.ts` e `test/utils/clean-database.ts` (adicione `prisma.post.deleteMany()` na limpeza) e siga o padrão de `test/users.e2e-spec.ts`.
-
-## Checklist rápido
-
-- [ ] Model no `schema.prisma` + migration
-- [ ] DTOs com Zod (`createZodDto`)
-- [ ] Entity (mesmo sem campo sensível ainda)
-- [ ] Service sem lógica no controller
-- [ ] Permissions novas cadastradas em `permissions.ts` e `role-permissions.ts`, se necessário
-- [ ] Module registrado no `AppModule`
-- [ ] Teste unitário do service
-- [ ] Teste e2e do fluxo principal
-- [ ] Atualizar `ROADMAP.md` se o módulo fechar um item do roadmap
+# Como adicionar um novo módulo
+
+Este guia mostra o passo a passo pra adicionar um recurso novo seguindo as convenções do NestForge, usando um módulo `posts` (posts de blog) como exemplo. Adapte os nomes pro seu caso.
+
+## 1. Adicione o model no Prisma
+
+Em `prisma/schema.prisma`:
+
+```prisma
+model Post {
+  // nestforge:feature:database:relational
+  id        String   @id @default(uuid())
+  // nestforge:feature:database:relational:end
+  // nestforge:feature:database:mongodb
+  id        String   @id @default(auto()) @map("_id") @db.ObjectId
+  // nestforge:feature:database:mongodb:end
+  title     String
+  content   String
+  // nestforge:feature:database:relational
+  authorId  String
+  // nestforge:feature:database:relational:end
+  // nestforge:feature:database:mongodb
+  authorId  String   @db.ObjectId
+  // nestforge:feature:database:mongodb:end
+  author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("posts")
+}
+```
+
+Não esqueça de adicionar a relação inversa no `model User`:
+
+```prisma
+posts Post[]
+```
+
+Em PostgreSQL, MySQL ou SQLite, gere a migration:
+
+```bash
+npx prisma migrate dev --name add_posts
+```
+
+Em MongoDB, envie o schema diretamente:
+
+```bash
+npm run prisma:push
+```
+
+## 2. Crie a estrutura de pastas
+
+```
+src/posts/
+├── dto/
+│   ├── create-post.dto.ts
+│   └── update-post.dto.ts
+├── entities/
+│   └── post.entity.ts
+├── posts.controller.ts
+├── posts.service.ts
+└── posts.module.ts
+```
+
+## 3. DTOs com Zod
+
+`src/posts/dto/create-post.dto.ts`:
+
+```ts
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const createPostSchema = z.object({
+  title: z.string().min(3).describe('Título do post'),
+  content: z.string().min(10).describe('Conteúdo do post'),
+});
+
+export class CreatePostDto extends createZodDto(createPostSchema) {}
+```
+
+`src/posts/dto/update-post.dto.ts`:
+
+```ts
+import { createZodDto } from 'nestjs-zod';
+import { createPostSchema } from './create-post.dto';
+
+export const updatePostSchema = createPostSchema.partial();
+
+export class UpdatePostDto extends createZodDto(updatePostSchema) {}
+```
+
+## 4. Entity (o que a API expõe)
+
+`src/posts/entities/post.entity.ts` — mesmo se não houver nada sensível pra esconder agora, criar a entity já deixa o padrão pronto pra quando houver:
+
+```ts
+export class PostEntity {
+  id: string;
+  title: string;
+  content: string;
+  authorId: string;
+  createdAt: Date;
+  updatedAt: Date;
+
+  constructor(partial: Partial<PostEntity>) {
+    Object.assign(this, partial);
+  }
+}
+```
+
+## 5. Service (regra de negócio)
+
+`src/posts/posts.service.ts`:
+
+```ts
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import { CreatePostDto } from './dto/create-post.dto';
+import { UpdatePostDto } from './dto/update-post.dto';
+import { PostEntity } from './entities/post.entity';
+
+@Injectable()
+export class PostsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async create(authorId: string, dto: CreatePostDto) {
+    const post = await this.prisma.post.create({ data: { ...dto, authorId } });
+    return new PostEntity(post);
+  }
+
+  async findOne(id: string) {
+    const post = await this.prisma.post.findUnique({ where: { id } });
+    if (!post) throw new NotFoundException('Post não encontrado');
+    return new PostEntity(post);
+  }
+
+  async update(id: string, dto: UpdatePostDto) {
+    await this.findOne(id);
+    const post = await this.prisma.post.update({ where: { id }, data: dto });
+    return new PostEntity(post);
+  }
+
+  async remove(id: string) {
+    await this.findOne(id);
+    await this.prisma.post.delete({ where: { id } });
+    return { message: 'Post removido com sucesso' };
+  }
+}
+```
+
+## 6. Controller (guards + permissions)
+
+Se o recurso precisa de controle de acesso, adicione a permission em `src/common/constants/permissions.ts` e no mapeamento `src/common/constants/role-permissions.ts` antes de usar:
+
+```ts
+// permissions.ts
+export enum Permission {
+  // ...existentes
+  PostCreate = 'post:create',
+  PostDelete = 'post:delete',
+}
+```
+
+`src/posts/posts.controller.ts`:
+
+```ts
+import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { PostsService } from './posts.service';
+import { CreatePostDto } from './dto/create-post.dto';
+import { UpdatePostDto } from './dto/update-post.dto';
+import { Permissions } from '../common/decorators/permissions.decorator';
+import { Permission } from '../common/constants/permissions';
+import { CurrentUser } from '../common/decorators/current-user.decorator';
+
+@ApiTags('posts')
+@ApiBearerAuth()
+@Controller('posts')
+export class PostsController {
+  constructor(private readonly postsService: PostsService) {}
+
+  @Post()
+  @Permissions(Permission.PostCreate)
+  create(@CurrentUser() user: { id: string }, @Body() dto: CreatePostDto) {
+    return this.postsService.create(user.id, dto);
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.postsService.findOne(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() dto: UpdatePostDto) {
+    return this.postsService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @Permissions(Permission.PostDelete)
+  remove(@Param('id') id: string) {
+    return this.postsService.remove(id);
+  }
+}
+```
+
+## 7. Module
+
+`src/posts/posts.module.ts`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { PostsService } from './posts.service';
+import { PostsController } from './posts.controller';
+
+@Module({
+  controllers: [PostsController],
+  providers: [PostsService],
+  exports: [PostsService],
+})
+export class PostsModule {}
+```
+
+Registre no `src/app.module.ts` (dentro do array `imports`):
+
+```ts
+import { PostsModule } from './posts/posts.module';
+// ...
+PostsModule,
+```
+
+## 8. Testes
+
+- **Unitário** (`src/posts/posts.service.spec.ts`): mocke o `PrismaService` como em `src/users/users.service.spec.ts` — sem banco real.
+- **E2e** (`test/posts.e2e-spec.ts`): use os helpers de `test/utils/e2e-setup.ts` e `test/utils/clean-database.ts` (adicione `prisma.post.deleteMany()` na limpeza) e siga o padrão de `test/users.e2e-spec.ts`.
+
+## Checklist rápido
+
+- [ ] Model no `schema.prisma` + migration ou `prisma:push`
+- [ ] DTOs com Zod (`createZodDto`)
+- [ ] Entity (mesmo sem campo sensível ainda)
+- [ ] Service sem lógica no controller
+- [ ] Permissions novas cadastradas em `permissions.ts` e `role-permissions.ts`, se necessário
+- [ ] Module registrado no `AppModule`
+- [ ] Teste unitário do service
+- [ ] Teste e2e do fluxo principal
+- [ ] Atualizar `ROADMAP.md` se o módulo fechar um item do roadmap