@nest-arch/tui 0.4.3 → 0.4.5

package/dist/templates/base/src/database/adapters/interfaces/db-adapter.interface.ts.hbs

@@ -12,10 +12,10 @@ import type { Collection, Document } from "mongodb";
 {{/if}}
 export interface IMongoAdapter<TClient = unknown> {
 {{#if useRawSql}}
-  collection<T extends Document = Document>(name: string): Collection<T>;
+  collection: <T extends Document = Document>(name: string) => Collection<T>;
 {{else}}
-  collection<T = unknown>(name: string): T;
+  collection: <T = unknown>(name: string) => T;
 {{/if}}
-  getClient(): TClient;
+  getClient: () => TClient;
 }
 {{/if}}

package/dist/templates/base/src/database/adapters/mongo/prisma-mongo.adapter.ts.hbs

@@ -23,7 +23,7 @@ import type { Prisma, PrismaClient } from '../../orm/prisma/generated/client.js'
 {{/if}}
 
 @Injectable()
-export class PrismaMongoAdapter implements IMongoAdapter<any> {
+export class PrismaMongoAdapter implements IMongoAdapter {
 {{#if isPrisma8}}
   readonly client = db;
 
@@ -31,8 +31,8 @@ export class PrismaMongoAdapter implements IMongoAdapter<any> {
     return ((this.client as any).orm as any)?.[name] as T;
   }
 
-  async runCommand(command: unknown): Promise<unknown> {
-    return (this.client as any).query?.(command);
+  runCommand(command: unknown): Promise<unknown> {
+    return (this.client as { query?: (input: unknown) => Promise<unknown> }).query?.(command) ?? Promise.resolve(undefined);
   }
 
   getClient() {
@@ -46,7 +46,7 @@ export class PrismaMongoAdapter implements IMongoAdapter<any> {
     return this.prisma[name as keyof PrismaClient] as T;
   }
 
-  async runCommand(command: Prisma.InputJsonObject): Promise<unknown> {
+  runCommand(command: Prisma.InputJsonObject): Promise<unknown> {
     return this.prisma.$runCommandRaw(command);
   }
 

package/dist/templates/base/src/database/index.ts.hbs

@@ -4,12 +4,21 @@ export * from './db.module.js';
 export * from './db.service.js';
 {{#if usePrisma}}
 {{#if isPrisma6}}
-export type { PrismaClient, Todo } from '@prisma/client';
+export type { PrismaClient } from '@prisma/client';
+{{#if hasTodoExample}}
+export type { Todo } from '@prisma/client';
+{{/if}}
 {{else}}
 {{#if isMonorepo}}
-export type { PrismaClient, Todo } from './database/orm/prisma/generated/client.js';
+export type { PrismaClient } from './database/orm/prisma/generated/client.js';
+{{#if hasTodoExample}}
+export type { Todo } from './database/orm/prisma/generated/client.js';
+{{/if}}
 {{else}}
-export type { PrismaClient, Todo } from './orm/prisma/generated/client.js';
+export type { PrismaClient } from './orm/prisma/generated/client.js';
+{{#if hasTodoExample}}
+export type { Todo } from './orm/prisma/generated/client.js';
+{{/if}}
 {{/if}}
 {{/if}}
 {{/if}}

package/dist/templates/base/test/app.e2e-spec.ts.hbs

@@ -7,7 +7,7 @@ import { Test, TestingModule } from "@nestjs/testing";
 import { createServer } from "node:http";
 import { generateKeyPairSync, createSign } from "node:crypto";
 {{/if}}
-{{#if (and isPassportAuth hasRateLimiting hasDatabase)}}
+{{#if (and hasTrustedProxy isPassportAuth hasRateLimiting hasDatabase)}}
 import { createServer, request as httpRequest } from "node:http";
 {{/if}}
 {{#if hasTrustedProxy}}
@@ -319,8 +319,8 @@ describe("AppController (e2e)", () => {
 {{#if (and hasHealthCheck hasDatabase (or usePrisma useTypeorm useDrizzle))}}
   it("reports database readiness failure with HTTP 503", async () => {
     const db = app.get(DbService);
-    const database = {{#if usePrisma}}db.prisma{{else if useTypeorm}}db.typeorm{{else}}db.drizzle{{/if}};
-    const query = vi.spyOn(database, {{#if usePrisma}}"$queryRaw"{{else if useTypeorm}}"query"{{else if hasSqlite}}"get"{{else}}"execute"{{/if}})
+    const database = {{#if hasMongodb}}db.raw.mongo{{else if usePrisma}}db.prisma{{else if useTypeorm}}db.typeorm{{else}}db.drizzle{{/if}};
+    const query = vi.spyOn(database, {{#if hasMongodb}}{{#if usePrisma}}"$runCommandRaw"{{else}}"command"{{/if}}{{else if usePrisma}}"$queryRaw"{{else if useTypeorm}}"query"{{else if hasSqlite}}"get"{{else}}"execute"{{/if}})
       .mockRejectedValue(new Error("scenario database outage"));
     try {
       const response = await request(app.getHttpServer()).get("/health").expect(503);
@@ -344,7 +344,6 @@ describe("AppController (e2e)", () => {
   it("enforces todo ownership through authenticated tRPC procedures", async () => {
     const server = app.getHttpServer();
     const password = "Scenario-password-123!";
-    const origin = "http://localhost:3000";
     const call = (procedure: string, input?: unknown, credential?: { cookie?: string[]; token?: string }) => {
       const operation = procedure === "findAll"
         ? request(server).get("/trpc/todoRouter.findAll")
@@ -354,11 +353,10 @@ describe("AppController (e2e)", () => {
       if (input !== undefined) operation.send(input);
       return operation;
     };
-    const unwrap = (body: { result?: { data?: { json?: unknown } } }) =>
-      body.result?.data?.json ?? body.result?.data;
 {{#if isBetterAuth}}
     async function register(prefix: string) {
       const email = `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}@example.com`;
+      const origin = "http://localhost:3000";
       const response = await request(server).post("/api/auth/sign-up/email")
         .set("Origin", origin).send({ email, password, name: prefix }).expect(200);
       return { cookie: response.headers["set-cookie"] as string[] };
@@ -379,21 +377,50 @@ describe("AppController (e2e)", () => {
     const alice = await register("trpc-alice");
     const bob = await register("trpc-bob");
     const created = await call("create", { title: "Private tRPC todo", completed: false }, alice).expect(200);
-    const createdTodo = unwrap(created.body) as { id: string; title: string };
+    const createdTodo = (created.body.result?.data?.json ?? created.body.result?.data) as { id: string; title: string };
     expect(createdTodo.title).toBe("Private tRPC todo");
     const id = createdTodo.id;
-    const aliceTodos = unwrap((await call("findAll", undefined, alice).expect(200)).body) as { id: string }[];
+    const aliceResponse = await call("findAll", undefined, alice).expect(200);
+    const aliceTodos = aliceResponse.body.result?.data?.json ?? aliceResponse.body.result?.data as { id: string }[];
     expect(aliceTodos).toEqual(expect.arrayContaining([expect.objectContaining({ id })]));
-    const bobTodos = unwrap((await call("findAll", undefined, bob).expect(200)).body) as { id: string }[];
+    const bobResponse = await call("findAll", undefined, bob).expect(200);
+    const bobTodos = bobResponse.body.result?.data?.json ?? bobResponse.body.result?.data as { id: string }[];
     expect(bobTodos).not.toEqual(expect.arrayContaining([expect.objectContaining({ id })]));
     await call("update", { id, data: { completed: true } }, bob).expect(404);
     await call("delete", { id }, bob).expect(404);
     const updated = await call("update", { id, data: { completed: true } }, alice).expect(200);
-    expect((unwrap(updated.body) as { completed: boolean }).completed).toBe(true);
+    const updatedTodo = updated.body.result?.data?.json ?? updated.body.result?.data;
+    expect((updatedTodo as { completed: boolean }).completed).toBe(true);
     await call("delete", { id }, alice).expect(200);
   });
 {{/if}}
 
+{{#if (and hasTrpc hasTodoExample (not hasAuth))}}
+  it("creates, reads, updates, and deletes tRPC todos", async () => {
+    const server = app.getHttpServer();
+    const create = await request(server)
+      .post("/trpc/todoRouter.create")
+      .send({ title: "Public tRPC todo", completed: false })
+      .expect(200);
+    const created = create.body.result?.data?.json ?? create.body.result?.data;
+    expect(created.title).toBe("Public tRPC todo");
+    const id = created.id as string | number;
+
+    const list = await request(server).get("/trpc/todoRouter.findAll").expect(200);
+    const todos = list.body.result?.data?.json ?? list.body.result?.data;
+    expect(todos).toEqual(expect.arrayContaining([expect.objectContaining({ id })]));
+
+    const update = await request(server)
+      .post("/trpc/todoRouter.update")
+      .send({ id, data: { completed: true } })
+      .expect(200);
+    const updated = update.body.result?.data?.json ?? update.body.result?.data;
+    expect(updated.completed).toBe(true);
+
+    await request(server).post("/trpc/todoRouter.delete").send({ id }).expect(200);
+  });
+{{/if}}
+
 {{#if (eq auth "better-auth")}}
   it("registers, authenticates and revokes a persisted session", async () => {
     const email = `scenario-${Date.now()}@example.com`;
@@ -634,8 +661,14 @@ expect(revoked.body).toBeNull();
   it("throttles repeated tRPC procedure requests", async () => {
     const server = app.getHttpServer();
     server.setMaxListeners(100);
-    const procedure = () => request(server).get("/trpc/appRouter.testAuth");
+    const procedure = () => request(server).get(
+      "/trpc/appRouter.{{#if hasTrpcAndAuth}}testAuth{{else}}getHello{{/if}}"
+    );
+    {{#if hasTrpcAndAuth}}
     expect((await procedure()).status).toBe(401);
+    {{else}}
+    expect((await procedure()).status).toBe(200);
+    {{/if}}
     const responses = await Promise.all(
       Array.from({ length: 80 }, () => procedure())
     );

package/dist/templates/base/tsconfig.build.json.hbs

@@ -8,6 +8,7 @@
     "**/*spec.ts"
   ],
   "compilerOptions": {
+    "incremental": false,
     "rootDir": "./src",
     "strictNullChecks": true
   }

package/dist/templates/base/vitest.config.e2e.ts.hbs

@@ -5,8 +5,8 @@ export default defineConfig({
     tsconfigPaths: true,
   },
   test: {
-    include: ["**/*.e2e-spec.ts"],
     globals: true,
+    include: ["**/*.e2e-spec.ts"],
     root: "./",
   },
 });

package/dist/templates/base/vitest.config.ts.hbs

@@ -5,8 +5,8 @@ export default defineConfig({
     tsconfigPaths: true,
   },
   test: {
-    include: ["**/*.spec.ts"],
     globals: true,
+    include: ["**/*.spec.ts"],
     root: "./",
   },
 });

package/dist/templates/extras/health/src/health/health.controller.ts.hbs

@@ -28,7 +28,13 @@ export class HealthController {
       {{#if hasDatabase}}
       async () => {
         try {
-        {{#if (or usePrisma isPrisma8)}}
+        {{#if hasMongodb}}
+          {{#if usePrisma}}
+          await this.db.raw.mongo.$runCommandRaw({ ping: 1 });
+          {{else}}
+          await this.db.raw.mongo.command({ ping: 1 });
+          {{/if}}
+        {{else if (or usePrisma isPrisma8)}}
         await this.db.prisma.$queryRaw`SELECT 1`;
         {{else if useDrizzle}}
         {{#if hasSqlite}}
@@ -38,8 +44,6 @@ export class HealthController {
         {{/if}}
         {{else if useTypeorm}}
         await this.db.typeorm.query("SELECT 1");
-        {{else if hasMongodb}}
-        await this.db.raw.mongo.command({ ping: 1 });
         {{else}}
         await this.db.raw.sql.query("SELECT 1");
         {{/if}}

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

@@ -22,11 +22,9 @@ import {
 {{#if (or isPassportAuth isBetterAuth)}}
   ApiUnauthorizedResponse,
 {{/if}}
-} from "@nestjs/swagger";
-{{/if}}
-{{#if (and isPassportAuth swagger)}}
-import {
+{{#if isPassportAuth}}
   ApiBearerAuth,
+{{/if}}
 } from "@nestjs/swagger";
 {{/if}}
 {{#if (and isBetterAuth hasDatabase)}}
@@ -162,14 +160,14 @@ export class TodoController {
 {{/if}}
 {{/if}}
 {{#if (and isPassportAuth hasDatabase)}}
-  async delete(
+  delete(
     @Param("id") id: string,
     @CurrentUser() user: { id: string }
   ) {
     return this.todoService.delete(id, user.id);
   }
 {{else if (and isBetterAuth hasDatabase)}}
-  async delete(
+  delete(
     @Param("id") id: string,
     @Session() session: UserSession
   ) {

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

@@ -1,11 +1,8 @@
 {{#if hasTrpc}}
-import { Router, Query, Mutation, Ctx, Input{{#if hasTrpcAndAuth}}, UseMiddlewares{{/if}} } from "nestjs-trpc";
+import { Router, Query, Mutation{{#if hasTrpcAndAuth}}, Ctx, UseMiddlewares{{/if}}, Input } from "nestjs-trpc";
 import { NotFoundException } from "@nestjs/common";
 import { TRPCError } from "@trpc/server";
-import z from "zod";
-{{#if (and hasTrpcAndAuth isBetterAuth)}}
-import type { UserSession } from "../../auth/auth.js";
-{{/if}}
+import { z } from "zod";
 {{#if hasTrpcAndAuth}}
 import { AuthTRPCMiddleware } from "../../libs/middlewares/auth.trpc.middleware.js";
 import type { InnerContext } from "../../libs/trpc/inner.context.js";
@@ -46,26 +43,28 @@ export class TodoRouter {
 
   @Mutation({ input: updateTodoInput, output: todoSchema })
   @UseMiddlewares(AuthTRPCMiddleware)
-  update(@Ctx() ctx: InnerContext, @Input() input: { id: string | number; data: UpdateTodoDto }) {
-    return this.todoService.update(String(input.id), input.data, ctx.session!.user.id)
-      .catch((error: unknown) => {
-        if (error instanceof NotFoundException) {
-          throw new TRPCError({ code: "NOT_FOUND", message: error.message });
-        }
-        throw error;
-      });
+  async update(@Ctx() ctx: InnerContext, @Input() input: { id: string | number; data: UpdateTodoDto }) {
+    try {
+      return await this.todoService.update(String(input.id), input.data, ctx.session!.user.id);
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw new TRPCError({ code: "NOT_FOUND", message: error.message });
+      }
+      throw error;
+    }
   }
 
   @Mutation({ input: z.object({ id: z.union([z.string(), z.number()]) }) })
   @UseMiddlewares(AuthTRPCMiddleware)
-  delete(@Ctx() ctx: InnerContext, @Input() input: { id: string | number }) {
-    return this.todoService.delete(String(input.id), ctx.session!.user.id)
-      .catch((error: unknown) => {
-        if (error instanceof NotFoundException) {
-          throw new TRPCError({ code: "NOT_FOUND", message: error.message });
-        }
-        throw error;
-      });
+  async delete(@Ctx() ctx: InnerContext, @Input() input: { id: string | number }) {
+    try {
+      return await this.todoService.delete(String(input.id), ctx.session!.user.id);
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw new TRPCError({ code: "NOT_FOUND", message: error.message });
+      }
+      throw error;
+    }
   }
 {{else}}
   @Query({ output: z.array(todoSchema) })
@@ -79,25 +78,27 @@ export class TodoRouter {
   }
 
   @Mutation({ input: updateTodoInput, output: todoSchema })
-  update(@Input() input: { id: string; data: UpdateTodoDto }) {
-    return this.todoService.update(input.id, input.data)
-      .catch((error: unknown) => {
-        if (error instanceof NotFoundException) {
-          throw new TRPCError({ code: "NOT_FOUND", message: error.message });
-        }
-        throw error;
-      });
+  async update(@Input() input: { id: string; data: UpdateTodoDto }) {
+    try {
+      return await this.todoService.update(input.id, input.data);
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw new TRPCError({ code: "NOT_FOUND", message: error.message });
+      }
+      throw error;
+    }
   }
 
   @Mutation({ input: z.object({ id: z.union([z.string(), z.number()]) }) })
-  delete(@Input() input: { id: string | number }) {
-    return this.todoService.delete(String(input.id))
-      .catch((error: unknown) => {
-        if (error instanceof NotFoundException) {
-          throw new TRPCError({ code: "NOT_FOUND", message: error.message });
-        }
-        throw error;
-      });
+  async delete(@Input() input: { id: string | number }) {
+    try {
+      return await this.todoService.delete(String(input.id));
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw new TRPCError({ code: "NOT_FOUND", message: error.message });
+      }
+      throw error;
+    }
   }
 {{/if}}
 }

package/dist/templates/monorepo/apps/api-gateway/test/app.e2e-spec.ts.hbs

@@ -4,7 +4,10 @@ import { Test, TestingModule } from "@nestjs/testing";
 import { FastifyAdapter } from "@nestjs/platform-fastify";
 {{/if}}
 import request from "supertest";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, it } from "vitest";
+{{#if (eq auth "better-auth")}}
+import { expect } from "vitest";
+{{/if}}
 import type { App } from "supertest/types";
 
 import { AppModule } from "./../src/app.module.js";

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

@@ -1,10 +1,43 @@
+{{#if (includes microservices "grpc")}}
 import { Controller, Get } from "@nestjs/common";
-import { {{#if (includes microservices "grpc")}}GrpcMethod{{else}}MessagePattern{{/if}} } from "@nestjs/microservices";
+import { GrpcMethod } from "@nestjs/microservices";
+{{else}}
+import { Controller, Get, Logger, Param } from "@nestjs/common";
+import { EventPattern, MessagePattern } from "@nestjs/microservices";
+{{/if}}
 
 import { AppService } from "./app.service.js";
 
+{{#unless (includes microservices "grpc")}}
+type AuditEvent = {
+  id: string;
+  payload: Record<string, unknown>;
+  source: string;
+};
+
+const isAuditEvent = (value: unknown): value is AuditEvent => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value as Record<string, unknown>;
+  return (
+    typeof candidate.id === "string" &&
+    candidate.id.trim().length > 0 &&
+    typeof candidate.source === "string" &&
+    candidate.source.trim().length > 0 &&
+    typeof candidate.payload === "object" &&
+    candidate.payload !== null &&
+    !Array.isArray(candidate.payload)
+  );
+};
+{{/unless}}
+
 @Controller()
 export class AppController {
+  {{#unless (includes microservices "grpc")}}
+  private readonly logger = new Logger(AppController.name);
+  {{/unless}}
+
   constructor(private readonly appService: AppService) {}
 
   @Get()
@@ -12,6 +45,24 @@ export class AppController {
     return this.appService.getHello();
   }
 
+  {{#unless (includes microservices "grpc")}}
+  @Get("events/:id")
+  getAuditEvent(
+    @Param("id") id: string
+  ): { id: string; payload: Record<string, unknown>; source: string } | null {
+    return this.appService.getAuditEvent(id);
+  }
+
+  @EventPattern("audit")
+  handleAuditEvent(data: unknown): void {
+    if (!isAuditEvent(data)) {
+      this.logger.warn("Discarded malformed audit event payload");
+      return;
+    }
+    this.appService.recordAuditEvent(data);
+  }
+  {{/unless}}
+
   {{#if (includes microservices "grpc")}}
   @GrpcMethod("AppService", "Ping")
   handleGrpcPing(): { message: string } {

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

@@ -5,6 +5,27 @@ import { DbService } from "./database/db.service.js";
 
 @Injectable()
 export class AppService {
+  {{#unless (includes microservices "grpc")}}
+  private readonly auditEvents = new Map<
+    string,
+    { id: string; payload: Record<string, unknown>; source: string }
+  >();
+
+  recordAuditEvent(event: {
+    id: string;
+    payload: Record<string, unknown>;
+    source: string;
+  }): void {
+    this.auditEvents.set(event.id, event);
+  }
+
+  getAuditEvent(
+    id: string
+  ): { id: string; payload: Record<string, unknown>; source: string } | null {
+    return this.auditEvents.get(id) ?? null;
+  }
+
+  {{/unless}}
   {{#if (or hasDatabase hasOrm)}}
   constructor(private readonly db: DbService) {}
 

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

@@ -1,9 +1,10 @@
-import { NestFactory } from "@nestjs/core";
 {{#if (eq httpProvider "fastify")}}
 import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
 {{/if}}
 import { Logger } from "@nestjs/common";
-import { Transport, type MicroserviceOptions } from "@nestjs/microservices";
+import { NestFactory } from "@nestjs/core";
+import { Transport } from "@nestjs/microservices";
+import type { MicroserviceOptions } from "@nestjs/microservices";
 
 import { AppModule } from "./app.module.js";
 import { env } from "./config/env.js";
@@ -27,19 +28,36 @@ async function bootstrap() {
   app.enableShutdownHooks();
 
   app.connectMicroservice<MicroserviceOptions>({
-    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}},
     options: {
-      {{#if (includes microservices "redis")}}host: new URL(env.REDIS_URL).hostname, port: Number(new URL(env.REDIS_URL).port || 6379),{{/if}}
-      {{#if (includes microservices "mqtt")}}url: env.MQTT_URL ?? "mqtt://127.0.0.1:1883",{{/if}}
-      {{#if (includes microservices "nats")}}servers: [env.NATS_URL ?? "nats://127.0.0.1:4222"],{{/if}}
-      {{#if (includes microservices "rabbitmq")}}urls: [env.RABBITMQ_URL ?? "amqp://127.0.0.1:5672"], queue: "ping", queueOptions: { durable: false },{{/if}}
-      {{#if (includes microservices "kafka")}}client: { brokers: [env.KAFKA_BROKER ?? "127.0.0.1:9092"] },{{/if}}
-      {{#if (includes microservices "grpc")}}url: env.GRPC_URL ?? "0.0.0.0:5000", package: "app", protoPath: "proto/app.proto",{{/if}}
+      {{#if (includes microservices "kafka")}}
+      client: { brokers: [env.KAFKA_BROKER ?? "127.0.0.1:9092"] },
+      {{/if}}
+      {{#if (includes microservices "grpc")}}
+      package: "app",
+      protoPath: "proto/app.proto",
+      url: env.GRPC_URL ?? "0.0.0.0:5000",
+      {{/if}}
+      {{#if (includes microservices "rabbitmq")}}
+      queue: "ping",
+      queueOptions: { durable: false },
+      urls: [env.RABBITMQ_URL ?? "amqp://127.0.0.1:5672"],
+      {{/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 ?? "nats://127.0.0.1:4222"],
+      {{/if}}
+      {{#if (includes microservices "mqtt")}}
+      url: env.MQTT_URL ?? "mqtt://127.0.0.1:1883",
+      {{/if}}
       {{#unless (or (includes microservices "redis") (includes microservices "mqtt") (includes microservices "nats") (includes microservices "rabbitmq") (includes microservices "kafka") (includes microservices "grpc"))}}
       host: "0.0.0.0",
       port: env.MICROSERVICE_PORT,
       {{/unless}}
     },
+    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}},
   });
 
   {{#if swagger}}

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

@@ -1,13 +1,15 @@
-import { type INestApplication } from "@nestjs/common";
-import {
-  ClientProxyFactory,
-  {{#if (includes microservices "grpc")}}type ClientGrpc,{{else if (includes microservices "kafka")}}type ClientKafka,{{else}}type ClientProxy,{{/if}}
-  type MicroserviceOptions,
-  Transport,
-} from "@nestjs/microservices";
+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 { firstValueFrom, type Observable } from "rxjs";
+import request from "supertest";
+{{/unless}}
+import { firstValueFrom } from "rxjs";
+{{#if (includes microservices "grpc")}}
+import type { Observable } from "rxjs";
+{{/if}}
 import { afterAll, expect, it } from "vitest";
 
 import { AppModule } from "../src/app.module.js";
@@ -16,21 +18,40 @@ 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 "redis")}}host: new URL(env.REDIS_URL).hostname, port: Number(new URL(env.REDIS_URL).port || 6379),{{/if}}
-  {{#if (includes microservices "mqtt")}}url: env.MQTT_URL,{{/if}}
-  {{#if (includes microservices "nats")}}servers: [env.NATS_URL],{{/if}}
-  {{#if (includes microservices "rabbitmq")}}urls: [env.RABBITMQ_URL], queue: "ping", queueOptions: { durable: false },{{/if}}
-  {{#if (includes microservices "kafka")}}client: { brokers: [env.KAFKA_BROKER] }, consumer: { groupId: "ping-consumer" },{{/if}}
-  {{#if (includes microservices "grpc")}}url: env.GRPC_URL, package: "app", protoPath: "proto/app.proto",{{/if}}
+  {{#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;
-let client{{#if (includes microservices "grpc")}}: ClientGrpc = ClientProxyFactory.create({ transport, options } as MicroserviceOptions) as unknown as ClientGrpc;{{else if (includes microservices "kafka")}}: ClientKafka = ClientProxyFactory.create({ transport, options } as MicroserviceOptions) as ClientKafka;{{else}}: ClientProxy = ClientProxyFactory.create({ transport, options } as MicroserviceOptions);{{/if}}
+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 () => {
   const module = await Test.createTestingModule({ imports: [AppModule] }).compile();
   app = module.createNestApplication();
-  app.connectMicroservice<MicroserviceOptions>({ transport, options } as MicroserviceOptions);
+  app.connectMicroservice<MicroserviceOptions>({ options, transport } as MicroserviceOptions);
+  app.setGlobalPrefix("api");
   await app.startAllMicroservices();
   await app.init();
   {{#if (includes microservices "kafka")}}
@@ -42,7 +63,7 @@ it("sends ping through the selected message transport", async () => {
   try {
     await client.connect();
   } catch {
-    await delay(1_000);
+    await delay(1000);
     await client.connect();
   }
   {{else}}
@@ -55,12 +76,23 @@ it("sends ping through the selected message transport", async () => {
     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", source: "scenario", payload: "healthy" };
+  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", source: "scenario", payload: { healthy: true } };
+  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);