@nest-arch/tui 0.5.0 → 0.5.1

package/dist/templates/feature/rest/todo-example/src/api/todo/todo.service.ts.hbs

@@ -1,25 +1,123 @@
+{{#if (and hasMongodb useTypeorm)}}
+import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
+import { ObjectId } from "mongodb";
+import type { Document, WithId } from "mongodb";
+
+import { DbService } from "../../database/db.service.js";
+import { CreateTodoDto } from "./dto/create-todo.dto.js";
+import { UpdateTodoDto } from "./dto/update-todo.dto.js";
+
+interface TodoDocument extends Document {
+  completed: boolean;
+  createdAt: Date;
+  description?: string;
+  title: string;
+  updatedAt: Date;
+}
+
+const serialize = ({ _id, ...todo }: WithId<TodoDocument>) => ({
+  ...todo,
+  id: _id.toHexString(),
+});
+
+function objectId(id: string): ObjectId {
+  if (!/^[a-f0-9]{24}$/iu.test(id)) {
+    throw new BadRequestException("Invalid todo identifier");
+  }
+  return new ObjectId(id);
+}
+
+@Injectable()
+export class TodoService {
+  constructor(private readonly db: DbService) {}
+
+  private get todos() {
+    return this.db.mongo.collection<TodoDocument>("todos");
+  }
+
+  async findAll() {
+    const todos = await this.todos.find().sort({ _id: 1 }).limit(100).toArray();
+    return todos.map(serialize);
+  }
+
+  async create(input: CreateTodoDto) {
+    const now = new Date();
+    const todo = {
+      completed: input.completed ?? false,
+      createdAt: now,
+      ...(input.description === undefined ? {} : { description: input.description }),
+      title: input.title,
+      updatedAt: now,
+    };
+    const result = await this.todos.insertOne(todo);
+    return { ...todo, id: result.insertedId.toHexString() };
+  }
+
+  async update(id: string, input: UpdateTodoDto) {
+    const _id = objectId(id);
+    await this.todos.updateOne({ _id }, { $set: { ...input, updatedAt: new Date() } });
+    const todo = await this.todos.findOne({ _id });
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return serialize(todo);
+  }
+
+  async delete(id: string) {
+    const result = await this.todos.deleteOne({ _id: objectId(id) });
+    if (result.deletedCount === 0) {
+      throw new NotFoundException("Todo not found");
+    }
+    return { message: "Todo deleted successfully" };
+  }
+}
+{{else}}
 {{#if (and hasMongodb useRawSql)}}
 import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
-import { ObjectId, type WithId } from "mongodb";
+import { ObjectId } from "mongodb";
+import type { Document, WithId } from "mongodb";
+
 import { DbService } from "../../database/db.service.js";
 import { CreateTodoDto } from "./dto/create-todo.dto.js";
 import { UpdateTodoDto } from "./dto/update-todo.dto.js";
-interface TodoDocument { title: string; completed: boolean; description?: string; }
-const serialize = ({ _id, ...todo }: WithId<TodoDocument>) => ({ ...todo, id: _id.toHexString() });
+
+interface TodoDocument extends Document {
+  completed: boolean;
+  description?: string;
+  title: string;
+}
+
+const serialize = ({ _id, ...todo }: WithId<TodoDocument>) => ({
+  ...todo,
+  id: _id.toHexString(),
+});
+
 function objectId(id: string): ObjectId {
-  if (!/^[a-f0-9]{24}$/iu.test(id)) throw new BadRequestException("Invalid todo identifier");
+  if (!/^[a-f0-9]{24}$/iu.test(id)) {
+    throw new BadRequestException("Invalid todo identifier");
+  }
   return new ObjectId(id);
 }
+
 @Injectable()
 export class TodoService {
   constructor(private readonly db: DbService) {}
-  private get todos() { return this.db.raw.mongo.collection<TodoDocument>("todos"); }
+
+  private get todos() {
+    return this.db.raw.mongo.collection<TodoDocument>("todos");
+  }
+
   async findAll() {
     const todos = await this.todos.find().sort({ _id: 1 }).limit(100).toArray();
     return todos.map(serialize);
   }
+
   async create(input: CreateTodoDto) {
-    const todo = { title: input.title, completed: input.completed ?? false, ...(input.description === undefined ? {} : { description: input.description }) };
+    const todo = {
+      completed: input.completed ?? false,
+      ...(input.description === undefined ? {} : { description: input.description }),
+      title: input.title,
+    };
     const result = await this.todos.insertOne(todo);
     return { ...todo, id: result.insertedId.toHexString() };
   }
@@ -29,18 +127,22 @@ export class TodoService {
   async update(id: string, input: UpdateTodoDto) {
 {{/if}}
     const todo = await this.todos.findOneAndUpdate({ _id: objectId(id) }, { $set: input }, { returnDocument: "after" });
-    if (!todo) throw new NotFoundException("Todo not found");
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
     return serialize(todo);
   }
   async delete(id: string) {
     const result = await this.todos.deleteOne({ _id: objectId(id) });
-    if (result.deletedCount === 0) throw new NotFoundException("Todo not found");
+    if (result.deletedCount === 0) {
+      throw new NotFoundException("Todo not found");
+    }
     return { message: "Todo deleted successfully" };
   }
 }
 {{else}}
-{{#if (or hasTodoExample hasAuth isPrisma8 (and hasDatabase useTypeorm) (and hasDatabase useDrizzle hasMysql))}}
-import { Injectable, NotFoundException{{#if (and hasAuth hasPostgres useRawSql)}}, type OnModuleInit{{/if}} } from "@nestjs/common";
+{{#if (or (and hasTodoExample (not hasDatabase)) hasAuth isPrisma8 (and hasDatabase useTypeorm) (and hasDatabase useDrizzle (or hasMysql hasSqlserver)) (and hasMongodb usePrisma))}}
+import { {{#if (and hasMongodb usePrisma (not isPrisma8))}}BadRequestException, {{/if}}Injectable, NotFoundException{{#if (and hasAuth hasPostgres useRawSql)}}, type OnModuleInit{{/if}} } from "@nestjs/common";
 {{else}}
 import { Injectable } from "@nestjs/common";
 {{/if}}
@@ -58,7 +160,7 @@ import { and, eq } from "drizzle-orm";
 import { eq } from "drizzle-orm";
 {{/if}}
 {{/if}}
-{{#if useTypeorm}}
+{{#if (and useTypeorm (not hasMongodb))}}
 import { Todo } from "../../database/entities/todo.entity.js";
 {{/if}}
 {{#if (and hasAuth hasPostgres useRawSql)}}
@@ -79,6 +181,13 @@ export class TodoService implements OnModuleInit {
 {{else}}
 export class TodoService {
 {{/if}}
+{{#if (and hasMongodb usePrisma (not isPrisma8))}}
+  private assertMongoId(id: string): void {
+    if (!/^[a-f0-9]{24}$/iu.test(id)) {
+      throw new BadRequestException("Invalid todo identifier");
+    }
+  }
+{{/if}}
 {{#if hasDatabase}}
   constructor(private readonly db: DbService) {}
 {{else}}
@@ -333,6 +442,13 @@ export class TodoService {
     }
     return todo;
 {{else if usePrisma}}
+{{#if (and hasMongodb (not isPrisma8))}}
+    this.assertMongoId(id);
+    const existingTodo = await this.db.prisma.todo.findUnique({ where: { id } });
+    if (!existingTodo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{/if}}
     const result = await this.db.prisma.todo.update({ data: input, where: { id } });
     return result;
 {{else if useTypeorm}}
@@ -369,6 +485,13 @@ export class TodoService {
 {{#if isPrisma8}}
     await this.db.prisma.orm.public.Todo.where({ id: Number(id) }).delete();
 {{else if usePrisma}}
+{{#if (and hasMongodb (not isPrisma8))}}
+    this.assertMongoId(id);
+    const existingTodo = await this.db.prisma.todo.findUnique({ where: { id } });
+    if (!existingTodo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{/if}}
     await this.db.prisma.todo.delete({ where: { id } });
 {{else if useTypeorm}}
     await this.db.typeorm.getRepository(Todo).delete(id);
@@ -423,3 +546,4 @@ export class TodoService {
 }
 
 {{/if}}
+{{/if}}

package/dist/templates/single-project/architecture/nest-microservice/.env.hbs

@@ -1,6 +1,29 @@
 PORT=3000
+NODE_ENV=development
+TRUSTED_PROXY_IPS={{#each trustedProxyIps}}{{#unless @first}},{{/unless}}{{this}}{{/each}}
 MICROSERVICE_PORT=3001
-CORS_ORIGIN=http://localhost:3001
+CORS_ORIGIN=http://localhost:3000
+{{#if hasPostgres}}
+POSTGRES_URL=postgresql://postgres:postgres@localhost:5432/{{projectNameKebab}}_db?schema=public
+{{/if}}
+{{#if hasMysql}}
+MYSQL_URL=mysql://root:mysql@localhost:3306/{{projectNameKebab}}_db
+{{/if}}
+{{#if hasSqlite}}
+SQLITE_PATH=./src/database/dev.db
+{{/if}}
+{{#if hasSqlserver}}
+SQLSERVER_HOST=localhost
+SQLSERVER_PORT=1433
+SQLSERVER_DATABASE={{projectNameKebab}}_db
+SQLSERVER_USER=sa
+SQLSERVER_PASSWORD=DevOnly_Strong_Password_2026!X9
+SQLSERVER_ENCRYPT=true
+SQLSERVER_TRUST_SERVER_CERTIFICATE=true
+{{/if}}
+{{#if hasMongodb}}
+MONGODB_URL=mongodb://localhost:27017/{{projectNameKebab}}_db
+{{/if}}
 {{#if (includes microservices "redis")}}
 REDIS_PORT=6379
 REDIS_URL=redis://127.0.0.1:6379

package/dist/templates/single-project/architecture/nest-microservice/proto/app.proto.hbs

@@ -5,9 +5,22 @@ package app;
 service AppService {
   rpc Ping (PingRequest) returns (PingResponse);
   rpc Log (LogRequest) returns (LogResponse);
+  {{#if (and hasDatabase hasTodoExample)}}
+  rpc CreateTodo (CreateTodoRequest) returns (StorageResponse);
+  rpc ListTodos (PingRequest) returns (StorageResponse);
+  {{/if}}
 }
 
 message PingRequest {}
+{{#if (and hasDatabase hasTodoExample)}}
+message CreateTodoRequest {
+  string title = 1;
+}
+
+message StorageResponse {
+  string json = 1;
+}
+{{/if}}
 
 message PingResponse {
   string message = 1;

package/dist/templates/single-project/architecture/nest-microservice/src/app.controller.ts.hbs

@@ -40,6 +40,30 @@ export class AppController {
 
   constructor(private readonly appService: AppService) {}
 
+  {{#if (and hasDatabase hasTodoExample)}}
+  {{#if (includes microservices "grpc")}}
+  @GrpcMethod("AppService", "CreateTodo")
+  async createTodo(data: { title: string }): Promise<{ json: string }> {
+    return { json: JSON.stringify(await this.appService.createTodo(data)) };
+  }
+
+  @GrpcMethod("AppService", "ListTodos")
+  async listTodos(): Promise<{ json: string }> {
+    return { json: JSON.stringify(await this.appService.findTodos()) };
+  }
+  {{else}}
+  @MessagePattern("todo.create")
+  createTodo(data: { title: string }) {
+    return this.appService.createTodo(data);
+  }
+
+  @MessagePattern("todo.list")
+  listTodos() {
+    return this.appService.findTodos();
+  }
+  {{/if}}
+  {{/if}}
+
   @Get()
   getHello(): string {
     return this.appService.getHello();

package/dist/templates/single-project/architecture/nest-microservice/src/app.module.ts.hbs

@@ -13,6 +13,18 @@ import { AuthModule } from "./auth/auth.module.js";
 
 import { AppController } from "./app.controller.js";
 import { AppService } from "./app.service.js";
+{{#if hasTrpc}}
+import { TRPCModule } from "nestjs-trpc";
+import { AppRouterClass as AppRouter } from "./app.router.js";
+import { AppContext } from "./libs/trpc/context.js";
+import { AppErrorHandler } from "./libs/trpc/error.handler.js";
+{{#if hasRateLimiting}}
+import { RateLimitTRPCMiddleware } from "./libs/middlewares/rate-limit.trpc.middleware.js";
+{{/if}}
+{{#if hasTodoExample}}
+import { TodoRouter } from "./api/todo/todo.router.js";
+{{/if}}
+{{/if}}
 {{#if hasRateLimiting}}
 import { HttpThrottlerGuard } from "./http-throttler.guard.js";
 {{/if}}
@@ -31,12 +43,22 @@ import { HealthModule } from "./health/health.module.js";
       {{#if hasPostgres}}postgresUrl: env.POSTGRES_URL,{{/if}}
       {{#if hasMysql}}mysqlUrl: env.MYSQL_URL,{{/if}}
       {{#if hasSqlite}}sqlitePath: env.SQLITE_PATH,{{/if}}
+      {{#if hasSqlserver}}sqlserver: { database: env.SQLSERVER_DATABASE, options: { encrypt: env.SQLSERVER_ENCRYPT, trustServerCertificate: env.SQLSERVER_TRUST_SERVER_CERTIFICATE }, password: env.SQLSERVER_PASSWORD, port: env.SQLSERVER_PORT, server: env.SQLSERVER_HOST, user: env.SQLSERVER_USER },{{/if}}
       {{#if hasMongodb}}mongodbUrl: env.MONGODB_URL,{{/if}}
     }),
     {{/if}}
     {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
     AuthModule,
     {{/if}}
+    {{#if hasTrpc}}
+    TRPCModule.forRoot({
+      context: AppContext,
+      {{#if hasRateLimiting}}
+      globalMiddlewares: [RateLimitTRPCMiddleware],
+      {{/if}}
+      onError: AppErrorHandler,
+    }),
+    {{/if}}
     {{#if hasRateLimiting}}
     ThrottlerModule.forRoot([{ limit: 60, ttl: 60_000 }]),
     {{/if}}
@@ -49,6 +71,17 @@ import { HealthModule } from "./health/health.module.js";
   ],
   providers: [
     AppService,
+    {{#if hasTrpc}}
+    AppContext,
+    AppErrorHandler,
+    AppRouter,
+    {{#if hasRateLimiting}}
+    RateLimitTRPCMiddleware,
+    {{/if}}
+    {{#if hasTodoExample}}
+    TodoRouter,
+    {{/if}}
+    {{/if}}
     {{#if hasRateLimiting}}
     { provide: APP_GUARD, useClass: HttpThrottlerGuard },
     {{/if}}

package/dist/templates/single-project/architecture/nest-microservice/src/app.service.ts.hbs

@@ -1,6 +1,7 @@
 import { Injectable } from "@nestjs/common";
-{{#if (or hasDatabase hasOrm)}}
-import { DbService } from "./database/db.service.js";
+{{#if (and hasDatabase hasTodoExample)}}
+import { RpcException } from "@nestjs/microservices";
+import { TodoService } from "./api/todo/todo.service.js";
 {{/if}}
 
 @Injectable()
@@ -26,8 +27,19 @@ export class AppService {
   }
 
   {{/unless}}
-  {{#if (or hasDatabase hasOrm)}}
-  constructor(private readonly db: DbService) {}
+  {{#if (and hasDatabase hasTodoExample)}}
+  constructor(private readonly todos: TodoService) {}
+
+  createTodo(data: { title: string }) {
+    if (typeof data?.title !== "string" || data.title.trim().length === 0) {
+      throw new RpcException({ code: 3, message: "A non-empty title is required" });
+    }
+    return this.todos.create({ completed: false, title: data.title });
+  }
+
+  findTodos() {
+    return this.todos.findAll();
+  }
 
   {{/if}}
   getHello(): string {

package/dist/templates/single-project/architecture/nest-microservice/src/main.ts.hbs

@@ -1,7 +1,15 @@
+{{#if (includes microservices "grpc")}}
+import { fileURLToPath } from "node:url";
+{{/if}}
 {{#if (eq httpProvider "fastify")}}
 import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
 {{/if}}
+{{#if (includes addons "nestjs-zod")}}
 import { Logger } from "@nestjs/common";
+import { ZodValidationPipe } from "nestjs-zod";
+{{else}}
+import { Logger, StandardSchemaValidationPipe } from "@nestjs/common";
+{{/if}}
 import { NestFactory } from "@nestjs/core";
 import { Transport } from "@nestjs/microservices";
 import type { MicroserviceOptions } from "@nestjs/microservices";
@@ -22,9 +30,20 @@ import { AuthService } from "@thallesp/nestjs-better-auth";
 {{/if}}
 
 async function bootstrap() {
-  const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter()){{else}}(AppModule){{/if}};
+  const trustedProxyIps = env.TRUSTED_PROXY_IPS.split(",").map((ip) => ip.trim()).filter(Boolean);
+  const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter({ trustProxy: trustedProxyIps })){{else}}(AppModule){{/if}};
+  {{#unless (eq httpProvider "fastify")}}
+  if (trustedProxyIps.length > 0) {
+    app.getHttpAdapter().getInstance().set("trust proxy", trustedProxyIps);
+  }
+  {{/unless}}
   app.enableCors({ origin: env.CORS_ORIGIN });
   app.setGlobalPrefix("api");
+  {{#if (includes addons "nestjs-zod")}}
+  app.useGlobalPipes(new ZodValidationPipe());
+  {{else}}
+  app.useGlobalPipes(new StandardSchemaValidationPipe());
+  {{/if}}
   app.enableShutdownHooks();
 
   app.connectMicroservice<MicroserviceOptions>({
@@ -34,7 +53,7 @@ async function bootstrap() {
       {{/if}}
       {{#if (includes microservices "grpc")}}
       package: "app",
-      protoPath: "proto/app.proto",
+      protoPath: fileURLToPath(new URL("proto/app.proto", import.meta.url)),
       url: env.GRPC_URL ?? "0.0.0.0:5000",
       {{/if}}
       {{#if (includes microservices "rabbitmq")}}
@@ -78,8 +97,8 @@ async function bootstrap() {
             {{/if}}
             {{#if (includes apis "trpc")}}
             trpc: {
-              routerFilePath: "./{{trpcGeneratePath}}/server.ts",
               pathPrefix: "/trpc",
+              routerFilePath: "./{{trpcGeneratePath}}/server.ts",
             },
             {{/if}}
             zod: {
@@ -88,10 +107,10 @@ async function bootstrap() {
           },
           title: "{{projectNamePascalCase}} API",
           version: "1.0.0",
-      }),
-      {{#if (eq httpProvider "fastify")}}withFastify: true,{{/if}}
-      pageTitle: "{{projectNamePascalCase}} API Docs",
+        }),
+        pageTitle: "{{projectNamePascalCase}} API Docs",
         theme: "default",
+        {{#if (eq httpProvider "fastify")}}withFastify: true,{{/if}}
       }),
     );
     {{else}}

package/dist/templates/single-project/architecture/nest-microservice/test/microservice.e2e-spec.ts.hbs

@@ -1,137 +1,22 @@
 import type { INestApplication } from "@nestjs/common";
-import { ClientProxyFactory, Transport } from "@nestjs/microservices";
-import type { {{#if (includes microservices "grpc")}}ClientGrpc{{else if (includes microservices "kafka")}}ClientKafka{{else}}ClientProxy{{/if}}, MicroserviceOptions } from "@nestjs/microservices";
-import { Test } from "@nestjs/testing";
-{{#unless (includes microservices "grpc")}}
-import { setTimeout as delay } from "node:timers/promises";
-import request from "supertest";
-{{/unless}}
-{{#if (and (includes microservices "grpc") (or hasTodoExample hasHealthCheck hasRateLimiting))}}
-import request from "supertest";
-{{/if}}
-import { firstValueFrom } from "rxjs";
-{{#if (includes microservices "grpc")}}
-import type { Observable } from "rxjs";
+{{#if (eq httpProvider "fastify")}}
+import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
 {{/if}}
+import { Test } from "@nestjs/testing";
 import { afterAll, expect, it } from "vitest";
 
 import { AppModule } from "../src/app.module.js";
-import { env } from "../src/config/env.js";
-
-const transport = {{#if (includes microservices "redis")}}Transport.REDIS{{else if (includes microservices "mqtt")}}Transport.MQTT{{else if (includes microservices "nats")}}Transport.NATS{{else if (includes microservices "rabbitmq")}}Transport.RMQ{{else if (includes microservices "kafka")}}Transport.KAFKA{{else if (includes microservices "grpc")}}Transport.GRPC{{else}}Transport.TCP{{/if}};
-
-const options = {
-  {{#if (includes microservices "kafka")}}
-  client: { brokers: [env.KAFKA_BROKER] },
-  consumer: { groupId: "ping-consumer" },
-  {{/if}}
-  {{#if (includes microservices "grpc")}}
-  package: "app",
-  protoPath: "proto/app.proto",
-  url: env.GRPC_URL,
-  {{/if}}
-  {{#if (includes microservices "rabbitmq")}}
-  queue: "ping",
-  queueOptions: { durable: false },
-  urls: [env.RABBITMQ_URL],
-  {{/if}}
-  {{#if (includes microservices "redis")}}
-  host: new URL(env.REDIS_URL).hostname,
-  port: Number(new URL(env.REDIS_URL).port || 6379),
-  {{/if}}
-  {{#if (includes microservices "nats")}}
-  servers: [env.NATS_URL],
-  {{/if}}
-  {{#if (includes microservices "mqtt")}}
-  url: env.MQTT_URL,
-  {{/if}}
-};
 
 let app: INestApplication;
-const client{{#if (includes microservices "grpc")}}: ClientGrpc = ClientProxyFactory.create({ options, transport } as MicroserviceOptions) as unknown as ClientGrpc;{{else if (includes microservices "kafka")}}: ClientKafka = ClientProxyFactory.create({ options, transport } as MicroserviceOptions) as ClientKafka;{{else}}: ClientProxy = ClientProxyFactory.create({ options, transport } as MicroserviceOptions);{{/if}}
 
-it("sends ping through the selected message transport", async () => {
+it("serves the generated HTTP application", async () => {
   const module = await Test.createTestingModule({ imports: [AppModule] }).compile();
-  app = module.createNestApplication();
-  app.connectMicroservice<MicroserviceOptions>({ options, transport } as MicroserviceOptions);
+  app = module.createNestApplication{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(new FastifyAdapter()){{else}}(){{/if}};
   app.setGlobalPrefix("api");
-  await app.startAllMicroservices();
   await app.init();
-  {{#if (includes microservices "kafka")}}
-  client.subscribeToResponseOf("ping");
-  client.subscribeToResponseOf("log");
-  {{/if}}
-  {{#unless (includes microservices "grpc")}}
-  {{#if (includes microservices "kafka")}}
-  try {
-    await client.connect();
-  } catch {
-    await delay(1000);
-    await client.connect();
-  }
-  {{else}}
-  await client.connect();
-  {{/if}}
-  {{/unless}}
-  {{#if (includes microservices "grpc")}}
-  const service = client.getService<{
-    ping: (request: Record<string, never>) => Observable<{ message: string }>;
-    log: (request: { id: string; source: string; payload: string }) => Observable<{ id: string; source: string; payload: string }>;
-  }>("AppService");
-  await expect(firstValueFrom(service.ping({}))).resolves.toEqual({ message: "pong" });
-  const event = { id: "event-1", payload: "healthy", source: "scenario" };
-  await expect(firstValueFrom(service.log(event))).resolves.toEqual(event);
-  {{else}}
-  await expect(firstValueFrom(client.send<string, Record<string, never>>("ping", {}))).resolves.toBe("pong");
-  const event = { id: "event-1", payload: { healthy: true }, source: "scenario" };
-  await expect(firstValueFrom(client.send("log", event))).resolves.toEqual({ received: event });
-  const auditEvent = {
-    id: "audit-1",
-    payload: { healthy: true },
-    source: "scenario",
-  };
-  await firstValueFrom(client.emit("audit", auditEvent));
-  await delay(250);
-  const auditResponse = await request(app.getHttpServer())
-    .get(`/api/events/${auditEvent.id}`)
-    .expect(200);
-  expect(auditResponse.body).toEqual(auditEvent);
-  {{/if}}
-}, 60_000);
-
-{{#if (or hasTodoExample hasHealthCheck hasRateLimiting)}}
-it("serves the selected HTTP extras alongside the message transport", async () => {
-  const server = app.getHttpServer();
-{{#if hasTodoExample}}
-  const created = await request(server)
-    .post("/api/todos")
-    .send({ completed: false, title: "Microservice todo" })
-    .expect(201);
-  const todo = created.body as { id: string };
-  const listed = await request(server).get("/api/todos").expect(200);
-  expect(listed.body).toEqual(
-    expect.arrayContaining([expect.objectContaining({ id: todo.id })])
-  );
-  await request(server)
-    .put(`/api/todos/${todo.id}`)
-    .send({ completed: true })
-    .expect(200);
-  await request(server).delete(`/api/todos/${todo.id}`).expect(200);
-{{/if}}
-{{#if hasHealthCheck}}
-  const health = await request(server).get("/api/health").expect(200);
-  expect(health.body.info.app.status).toBe("up");
-{{/if}}
-{{#if hasRateLimiting}}
-  const responses = await Promise.all(
-    Array.from({ length: 80 }, () => request(server).get("/api"))
-  );
-  expect(responses.some((response) => response.status === 429)).toBe(true);
-{{/if}}
-}, 60_000);
-{{/if}}
+  expect(app.getHttpServer()).toBeDefined();
+});
 
 afterAll(async () => {
   await app?.close();
-  client.close();
 });

package/dist/templates/single-project/shared/config/env.ts.hbs

@@ -35,9 +35,15 @@ export const env = createEnv({
     {{#if (or (includes microservices "redis") (includes microservices "mqtt") (includes microservices "nats") (includes microservices "rabbitmq") (includes microservices "kafka") (includes microservices "grpc"))}}
     MICROSERVICE_PORT: z.string().transform(Number).default(3001),
     {{/if}}
+    {{#if hasMongodb}}
+    MONGODB_URL: z.url(),
+    {{/if}}
     {{#if (includes microservices "mqtt")}}
     MQTT_URL: z.url().default("mqtt://127.0.0.1:1883"),
     {{/if}}
+    {{#if hasMysql}}
+    MYSQL_URL: z.url(),
+    {{/if}}
     {{#if (includes microservices "nats")}}
     NATS_URL: z.url().default("nats://127.0.0.1:4222"),
     {{/if}}
@@ -48,34 +54,28 @@ export const env = createEnv({
       .string()
       .transform(Number)
       .default(3000),
+    {{#if hasPostgres}}
+    POSTGRES_URL: z.url(),
+    {{/if}}
     {{#if (includes microservices "rabbitmq")}}
     RABBITMQ_URL: z.url().default("amqp://127.0.0.1:5672"),
     {{/if}}
     {{#if (includes microservices "redis")}}
     REDIS_URL: z.url().default("redis://127.0.0.1:6379"),
     {{/if}}
-    TRUSTED_PROXY_IPS: z.string().default("{{#each trustedProxyIps}}{{#unless @first}},{{/unless}}{{this}}{{/each}}"),
-    {{#if hasPostgres}}
-    POSTGRES_URL: z.url(),
-    {{/if}}
-    {{#if hasMysql}}
-    MYSQL_URL: z.url(),
-    {{/if}}
     {{#if hasSqlite}}
     SQLITE_PATH: z.string().default("sqlite.db"),
     {{/if}}
     {{#if hasSqlserver}}
-    SQLSERVER_HOST: z.string().default("localhost"),
-    SQLSERVER_PORT: z.string().transform(Number).default(1433),
     SQLSERVER_DATABASE: z.string().default("{{projectNameKebab}}_db"),
-    SQLSERVER_USER: z.string(),
-    SQLSERVER_PASSWORD: z.string(),
     SQLSERVER_ENCRYPT: z.string().transform((value) => value !== "false").default(true),
+    SQLSERVER_HOST: z.string().default("localhost"),
+    SQLSERVER_PASSWORD: z.string(),
+    SQLSERVER_PORT: z.string().transform(Number).default(1433),
     SQLSERVER_TRUST_SERVER_CERTIFICATE: z.string().transform((value) => value === "true").default(false),
+    SQLSERVER_USER: z.string(),
     {{/if}}
-    {{#if hasMongodb}}
-    MONGODB_URL: z.url(),
-    {{/if}}
+    TRUSTED_PROXY_IPS: z.string().default("{{#each trustedProxyIps}}{{#unless @first}},{{/unless}}{{this}}{{/each}}"),
     {{#if hasGraphql}}
     GRAPHQL_PLAYGROUND: z
       .string()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-arch/tui",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "private": false,
   "description": "Interactive terminal UI for generating NestJS projects",
   "keywords": [
@@ -38,6 +38,7 @@
     "handlebars": "^4.7.8",
     "ink": "^5.0.1",
     "ink-text-input": "^6.0.0",
+    "jsonc-parser": "^3.3.1",
     "open": "^11.0.0",
     "react": "^18.3.1",
     "semver": "^7.8.5",