@nest-arch/tui 0.2.7 → 0.4.0

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

@@ -1,3 +1,37 @@
+{{#if (and hasMongodb useRawSql)}}
+import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
+import { ObjectId, type 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() });
+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.raw.mongo.collection<TodoDocument>("todos"); }
+  async findAll() { return (await this.todos.find().sort({ _id: 1 }).limit(100).toArray()).map(serialize); }
+  async create(input: CreateTodoDto) {
+    const todo = { title: input.title, completed: input.completed ?? false, ...(input.description === undefined ? {} : { description: input.description }) };
+    const result = await this.todos.insertOne(todo);
+    return { ...todo, id: result.insertedId.toHexString() };
+  }
+  async update(id: string, input: UpdateTodoDto) {
+    const todo = await this.todos.findOneAndUpdate({ _id: objectId(id) }, { $set: input }, { returnDocument: "after" });
+    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}}
 import { Injectable } from "@nestjs/common";
 {{#if hasDatabase}}
 {{#if isMonorepo}}
@@ -7,8 +41,12 @@ import { DbService } from "../../database/db.service.js";
 {{/if}}
 {{#if useDrizzle}}
 import * as schema from "../../database/orm/drizzle/schema.js";
+{{#if hasAuth}}
+import { and, eq } from "drizzle-orm";
+{{else}}
 import { eq } from "drizzle-orm";
 {{/if}}
+{{/if}}
 {{#if useTypeorm}}
 import { Todo } from "../../database/entities/todo.entity.js";
 {{/if}}
@@ -33,83 +71,109 @@ export class TodoService {
 {{#if hasDatabase}}
 {{#if hasAuth}}
   findAll(authorId: string) {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ authorId }).all();
+{{else if usePrisma}}
     return this.db.prisma.todo.findMany({ where: { authorId } });
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).find({ where: { authorId } });
+    return this.db.typeorm.getRepository(Todo).find({ where: { authorId } });
 {{else if useDrizzle}}
-    return this.db.select().from(schema.todos).where(eq(schema.todos.authorId, authorId));
+    return this.db.drizzle.select().from(schema.todos).where(eq(schema.todos.authorId, authorId));
 {{/if}}
   }
 
-  create(input: CreateTodoDto, authorId: string) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.create({ data: { ...input, authorId } });
+  async create(input: CreateTodoDto, authorId: string) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).create({ ...input, authorId });
+{{else if usePrisma}}
+    const todo = await this.db.prisma.todo.create({ data: { ...input, authorId } });
+    return todo;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).save(this.db.getRepository(Todo).create({ ...input, authorId }));
+    const todo = await this.db.typeorm.getRepository(Todo).save(this.db.typeorm.getRepository(Todo).create({ ...input, authorId }));
+    return todo;
 {{else if useDrizzle}}
-    return this.db.insert(schema.todos).values({ ...input, authorId }).returning();
+    return this.db.drizzle.insert(schema.todos).values({ ...input, authorId }).returning();
 {{/if}}
   }
 
-  update(id: string, input: UpdateTodoDto, authorId: string) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.update({ data: input, where: { authorId, id } });
+  async update(id: string, input: UpdateTodoDto, authorId: string) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).update(input);
+{{else if usePrisma}}
+    const result = await this.db.prisma.todo.update({ data: input, where: { authorId, id } });
+    return result;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).update({ authorId, id }, input);
+    const result = await this.db.typeorm.getRepository(Todo).update({ authorId, id }, input);
+    return result;
 {{else if useDrizzle}}
-    return this.db.update(schema.todos).set(input).where(eq(schema.todos.authorId, authorId) && eq(schema.todos.id, id)).returning();
+    return this.db.drizzle.update(schema.todos).set(input).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id)))).returning();
 {{/if}}
   }
 
   async delete(id: string, authorId: string) {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).delete();
+{{else if usePrisma}}
     await this.db.prisma.todo.delete({ where: { authorId, id } });
 {{else if useTypeorm}}
-    await this.db.getRepository(Todo).delete({ authorId, id });
+    await this.db.typeorm.getRepository(Todo).delete({ authorId, id });
 {{else if useDrizzle}}
-    await this.db.delete(schema.todos).where(eq(schema.todos.authorId, authorId) && eq(schema.todos.id, id));
+    await this.db.drizzle.delete(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
 {{/if}}
     return { message: "Todo deleted successfully" };
   }
 {{else}}
   findAll() {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).all();
+{{else if usePrisma}}
     return this.db.prisma.todo.findMany();
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).find();
+    return this.db.typeorm.getRepository(Todo).find();
 {{else if useDrizzle}}
-    return this.db.select().from(schema.todos);
+    return this.db.drizzle.select().from(schema.todos);
 {{/if}}
   }
 
-  create(input: CreateTodoDto) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.create({ data: input });
+  async create(input: CreateTodoDto) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).create(input);
+{{else if usePrisma}}
+    const todo = await this.db.prisma.todo.create({ data: input });
+    return todo;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).save(this.db.getRepository(Todo).create(input));
+    const todo = await this.db.typeorm.getRepository(Todo).save(this.db.typeorm.getRepository(Todo).create(input));
+    return todo;
 {{else if useDrizzle}}
-    return this.db.insert(schema.todos).values(input).returning();
+    const [todo] = await this.db.drizzle.insert(schema.todos).values(input).returning();
+    return todo;
 {{/if}}
   }
 
-  update(id: string, input: UpdateTodoDto) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.update({ data: input, where: { id } });
+  async update(id: string, input: UpdateTodoDto) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ id }).update(input);
+{{else if usePrisma}}
+    const result = await this.db.prisma.todo.update({ data: input, where: { id } });
+    return result;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).update(id, input);
+    const result = await this.db.typeorm.getRepository(Todo).update(id, input);
+    return result;
 {{else if useDrizzle}}
-    return this.db.update(schema.todos).set(input).where(eq(schema.todos.id, id)).returning();
+    const [todo] = await this.db.drizzle.update(schema.todos).set(input).where(eq(schema.todos.id, Number(id))).returning();
+    return todo;
 {{/if}}
   }
 
   async delete(id: string) {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ id }).delete();
+{{else if usePrisma}}
     await this.db.prisma.todo.delete({ where: { id } });
 {{else if useTypeorm}}
-    await this.db.getRepository(Todo).delete(id);
+    await this.db.typeorm.getRepository(Todo).delete(id);
 {{else if useDrizzle}}
-    await this.db.delete(schema.todos).where(eq(schema.todos.id, id));
+    await this.db.drizzle.delete(schema.todos).where(eq(schema.todos.id, Number(id)));
 {{/if}}
     return { message: "Todo deleted successfully" };
   }
@@ -143,3 +207,5 @@ export class TodoService {
   }
 {{/if}}
 }
+
+{{/if}}

package/dist/templates/monorepo/apps/api-gateway/package.json.hbs

@@ -45,7 +45,6 @@
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",
     "typescript": "catalog:",
-    "vite-tsconfig-paths": "^5.1.4",
     {{#if hasUltracite}}"ultracite": "7.8.0",{{/if}}
     "vitest": "^4.1.2"
   }

package/dist/templates/monorepo/apps/api-gateway/src/app.controller.spec.ts.hbs

@@ -1,7 +1,7 @@
 // oxlint-disable vitest/require-mock-type-parameters
 import type { TestingModule } from "@nestjs/testing";
 import { Test } from "@nestjs/testing";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it{{#if (or hasDatabase hasOrm)}}, vi{{/if}} } from "vitest";
 
 import { AppController } from "./app.controller.js";
 import { AppService } from "./app.service.js";

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

@@ -1,6 +1,10 @@
 import { INestApplication } from "@nestjs/common";
 import { Test, TestingModule } from "@nestjs/testing";
+{{#if (eq httpProvider "fastify")}}
+import { FastifyAdapter } from "@nestjs/platform-fastify";
+{{/if}}
 import request from "supertest";
+import { afterEach, beforeEach, describe, it } from "vitest";
 import type { App } from "supertest/types";
 
 import { AppModule } from "./../src/app.module.js";
@@ -13,15 +17,30 @@ describe("AppController (e2e)", () => {
       imports: [AppModule],
     }).compile();
 
+{{#if (eq httpProvider "fastify")}}
+    app = moduleFixture.createNestApplication(new FastifyAdapter());
+{{else}}
     app = moduleFixture.createNestApplication();
+{{/if}}
     await app.init();
+{{#if (eq httpProvider "fastify")}}
+    await app.getHttpAdapter().getInstance().ready();
+{{/if}}
   });
 
   it("/ (GET)", () => {
     return request(app.getHttpServer()).get("/").expect(200).expect("Hello World!");
   });
 
+  it("returns 404 for an unknown route", async () => {
+    await request(app.getHttpServer()).get("/__missing_route__").expect(404);
+  });
+
+  it("rejects unsupported methods", async () => {
+    await request(app.getHttpServer()).post("/").send({ unexpected: true }).expect(404);
+  });
+
   afterEach(async () => {
-    await app.close();
+    await app?.close();
   });
 });

package/dist/templates/monorepo/apps/api-gateway/tsconfig.build.json.hbs

@@ -2,7 +2,8 @@
   "$schema": "https://json.schemastore.org/tsconfig",
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "outDir": "./dist"
+    "outDir": "./dist",
+    "rootDir": "./src"
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]

package/dist/templates/monorepo/apps/api-gateway/vitest.config.e2e.ts.hbs

@@ -1,8 +1,9 @@
 import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
 
 export default defineConfig({
-  plugins: [tsconfigPaths()],
+  resolve: {
+    tsconfigPaths: true,
+  },
   test: {
     globals: true,
     root: "./",

package/dist/templates/monorepo/apps/api-gateway/vitest.config.ts.hbs

@@ -1,8 +1,9 @@
 import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
 
 export default defineConfig({
-  plugins: [tsconfigPaths()],
+  resolve: {
+    tsconfigPaths: true,
+  },
   test: {
     globals: true,
     root: "./",

package/dist/templates/monorepo/feature/graphql/src/graphql/resolvers/todo.resolver.ts.hbs

@@ -2,9 +2,13 @@
 import { UseGuards } from "@nestjs/common";
 {{/if}}
 import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+{{#if (and hasAuth hasDatabase)}}
+import { UserEntity } from "../../auth/decorators/index.js";
+import { GqlAuthGuard } from "../../auth/guards/gql-auth.guard.js";
+{{/if}}
+import { DbService } from "@repo/db";
 import { CreateTodoInput } from "../dto/create-todo.input.js";
 import { UpdateTodoInput } from "../dto/update-todo.input.js";
-import { DbService } from "@repo/db";
 {{#if useTypeorm}}
 import { GraphRelationBuilder } from "typeorm-relations-graphql";
 import { GraphQLResolveInfo } from "graphql";
@@ -14,11 +18,9 @@ import * as schema from "@repo/db/src/orm/drizzle/schema.js";
 {{/if}}
 {{#if (and hasAuth hasDatabase)}}
 import { Todo } from "../models/todo.model.js";
-import { UserEntity } from "../../auth/decorators/index.js";
-import { GqlAuthGuard } from "../../auth/guards/gql-auth.guard.js";
 {{/if}}
 
-@Resolver({{#if (and hasAuth hasDatabase)}}{{"("}}() => Todo){{/if}})
+@Resolver(() => Todo)
 export class TodoResolver {
   constructor(private readonly db: DbService) {}
 
@@ -28,11 +30,13 @@ export class TodoResolver {
   }{{#if hasDatabase}}
 
   @Query(() => [Todo])
-  todos({{#if useTypeorm}}info: GraphQLResolveInfo{{/if}}): Promise<Todo[]> {
+  todos({{#if useTypeorm}}info: GraphQLResolveInfo{{/if}}) {
     {{#if useTypeorm}}
     const builder = new GraphRelationBuilder(this.db.getDataSource());
     const relations = builder.buildForQuery(Todo, info, "todos");
     return this.db.getRepository(Todo).find({ relations });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).all();
     {{else if usePrisma}}
     return this.db.prisma.todo.findMany();
     {{else if useDrizzle}}
@@ -42,14 +46,12 @@ export class TodoResolver {
     {{/if}}
   }
 
-  @Mutation(() => Todo)
-  {{#if (and hasAuth hasDatabase)}}
   @UseGuards(GqlAuthGuard)
-  {{/if}}
+  @Mutation(() => Todo)
   createTodo(
-    @Args("input") input: CreateTodoInput{{#if (and hasAuth hasDatabase)}},
-    @UserEntity() user: { id: string }{{/if}}{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}
-  ): Promise<Todo> {
+    @UserEntity() user: { id: string },
+    @Args("input") input: CreateTodoInput{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}
+  ) {
     {{#if useTypeorm}}
     const entity = this.db.getRepository(Todo).create(input);
     const saved = await this.db.getRepository(Todo).save(entity);
@@ -59,9 +61,11 @@ export class TodoResolver {
       where: { id: saved.id },
       relations,
     });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).create({ ...input, authorId: user.id });
     {{else if usePrisma}}
     return this.db.prisma.todo.create({
-      data: { ...input{{#if (and hasAuth hasDatabase)}}, authorId: user.id{{/if}} },
+      data: { ...input, authorId: user.id },
     });
     {{else if useDrizzle}}
     const [todo] = await this.db.insert(schema.todos).values(input).returning();
@@ -71,13 +75,9 @@ export class TodoResolver {
     {{/if}}
   }
 
-  @Mutation(() => Todo)
-  {{#if (and hasAuth hasDatabase)}}
   @UseGuards(GqlAuthGuard)
-  {{/if}}
-  updateTodo(
-    @Args("input") input: UpdateTodoInput{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}
-  ): Promise<Todo> {
+  @Mutation(() => Todo)
+  updateTodo(@Args("input") input: UpdateTodoInput{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}) {
     const { id, ...data } = input;
     {{#if useTypeorm}}
     await this.db.getRepository(Todo).update(id, data);
@@ -87,6 +87,8 @@ export class TodoResolver {
       where: { id },
       relations,
     });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ id }).update(data);
     {{else if usePrisma}}
     return this.db.prisma.todo.update({ where: { id }, data });
     {{else if useDrizzle}}
@@ -101,14 +103,15 @@ export class TodoResolver {
     {{/if}}
   }
 
-  @Mutation(() => Boolean)
-  {{#if (and hasAuth hasDatabase)}}
   @UseGuards(GqlAuthGuard)
-  {{/if}}
+  @Mutation(() => Boolean)
   async deleteTodo(@Args("id") id: string): Promise<boolean> {
     {{#if useTypeorm}}
     const result = await this.db.getRepository(Todo).delete(id);
     return (result.affected ?? 0) > 0;
+    {{else if isPrisma8}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ id }).delete();
+    return true;
     {{else if usePrisma}}
     await this.db.prisma.todo.delete({ where: { id } });
     return true;

package/dist/templates/monorepo/packages/env/src/api-gateway.ts.hbs

@@ -1,6 +1,6 @@
 import "dotenv/config";
 import { createEnv } from "@t3-oss/env-core";
-import * as z from "zod";
+import { z } from "zod";
 
 export const env = createEnv({
   /**
@@ -31,7 +31,7 @@ export const env = createEnv({
       .default("development"),
     PORT: z
       .string()
-      .transform((val) => Number.parseInt(val, 10))
+      .transform(Number)
       .default(3000),
     {{#if hasPostgres}}
     POSTGRES_URL: z.url(),
@@ -51,9 +51,15 @@ export const env = createEnv({
       .transform((val) => val === "true")
       .default(true),
     {{/if}}
-    {{#if (and (eq auth "passport") hasDatabase)}}
+    {{#if (eq auth "passport")}}
     JWT_ACCESS_SECRET: z.string().min(32),
+    {{#if hasDatabase}}
     JWT_REFRESH_SECRET: z.string().min(32),
     {{/if}}
+    {{/if}}
+    {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+    BETTER_AUTH_SECRET: z.string().min(32),
+    BETTER_AUTH_URL: z.url(),
+    {{/if}}
   },
 });

package/dist/templates/monorepo/root/.gitignore.hbs

@@ -13,6 +13,7 @@ prisma/generated
 
 # Environment variables
 .env
+.env.test
 .env*.local
 
 # IDEs and editors

package/dist/templates/monorepo/root/pnpm-workspace.yaml.hbs

@@ -2,6 +2,10 @@ packages:
   - apps/*
   - packages/*
 allowBuilds:
+{{#if useDrizzle}}
+  esbuild: true
+{{/if}}
+  protobufjs: true
   '@nestjs/core': true
   esbuild: true
 {{#if swagger}}
@@ -16,6 +20,11 @@ allowBuilds:
 {{#if hasSqlite}}
   better-sqlite3: true
 {{/if}}
+{{#if isPrisma8}}
+  esbuild: true
+  msgpackr-extract: true
+  workerd: true
+{{/if}}
 catalog:
   "@types/node": ^22.13.14
   dotenv: ^17.2.2

package/dist/templates/monorepo/root/tsconfig.json.hbs

@@ -1,3 +1,3 @@
 {
-  "extends": "@repo-config/config/tsconfig.base.json"
+  "extends": "@repo/config/tsconfig.base.json"
 }

package/dist/templates/monorepo/root/turbo.json.hbs

@@ -10,6 +10,8 @@
     "lint": {
       "dependsOn": ["^lint"]
     },
+    "test": { "cache": false },
+    "test:e2e": { "cache": false },
     "check-types": {
       "dependsOn": ["^check-types"]
     },

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

@@ -16,10 +16,12 @@ SQLITE_PATH=file:./src/database/dev.db
 {{#if hasMongodb}}
 MONGODB_URL=mongodb://localhost:27017/{{projectNameKebab}}_db
 {{/if}}
-{{#if (and (eq auth "passport") hasDatabase)}}
+{{#if (eq auth "passport")}}
 JWT_ACCESS_SECRET=change-me-to-a-random-secret-at-least-32-characters-long
+{{#if hasDatabase}}
 JWT_REFRESH_SECRET=change-me-to-a-different-random-secret-at-least-32-characters
 {{/if}}
+{{/if}}
 {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
 BETTER_AUTH_SECRET=change-me-to-a-random-secret-at-least-32-characters-long
 BETTER_AUTH_URL=http://localhost:3000

package/dist/templates/single-project/architecture/nest-api/package.json.hbs

@@ -46,7 +46,6 @@
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",
     "typescript": "^6.0.2",
-    "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^4.1.2"
   }
 }

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

@@ -2,10 +2,18 @@ import { NestFactory } from "@nestjs/core";
 {{#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 { AppModule } from "./app.module.js";
 import { env } from "./config/env.js";
+{{#if isPrisma8}}
+import { connectDatabase } from "./prisma/db.js";
+{{/if}}
 {{#if swagger}}
 import { createDocs } from "./docs/create-docs.js";
 {{/if}}
@@ -20,6 +28,9 @@ import { auth } from "./auth/auth.js";
 {{/if}}
 
 async function bootstrap() {
+  {{#if isPrisma8}}
+  await connectDatabase();
+  {{/if}}
   const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter()){{else}}(AppModule){{/if}};
   app.enableCors({
     origin: env.CORS_ORIGIN,
@@ -27,7 +38,11 @@ async function bootstrap() {
   {{#if hasRest}}
   app.setGlobalPrefix("api");
   {{/if}}
+{{#if (includes addons "nestjs-zod")}}
+  app.useGlobalPipes(new ZodValidationPipe());
+{{else}}
   app.useGlobalPipes(new StandardSchemaValidationPipe());
+{{/if}}
   app.enableShutdownHooks();
   {{#if swagger}}
   if (env.NODE_ENV === "development") {
@@ -87,17 +102,17 @@ async function bootstrap() {
     });
     SwaggerModule.setup(docsPath, app, document);
     {{/if}}
-    Logger.log(`Swagger documentation available at http://localhost:${env.PORT ?? 3000}${docsPath}`, "SwaggerDocs");
+    Logger.log(`Swagger documentation available at http://localhost:${env.PORT}${docsPath}`, "SwaggerDocs");
   }
   {{/if}}
 
-  await app.listen(env.PORT ?? 3000);
+  await app.listen(env.PORT);
   {{#if hasRest}}
-  Logger.log(`Started backend server on http://localhost:${env.PORT ?? 3000}/api`, "Main");
+  Logger.log(`Started backend server on http://localhost:${env.PORT}/api`, "Main");
   {{else if hasTrpc}}
-  Logger.log(`Started trpc server on http://localhost:${env.PORT ?? 3000}/trpc`, "Main");
+  Logger.log(`Started trpc server on http://localhost:${env.PORT}/trpc`, "Main");
   {{else}}
-  Logger.log(`Started server on http://localhost:${env.PORT ?? 3000}`, "Main");
+  Logger.log(`Started server on http://localhost:${env.PORT}`, "Main");
   {{/if}}
 }
 await bootstrap();

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

@@ -1,6 +1,24 @@
 PORT=3000
 MICROSERVICE_PORT=3001
 CORS_ORIGIN=http://localhost:3001
+{{#if (includes microservices "redis")}}
+REDIS_URL=redis://127.0.0.1:6379
+{{/if}}
+{{#if (includes microservices "mqtt")}}
+MQTT_URL=mqtt://127.0.0.1:1883
+{{/if}}
+{{#if (includes microservices "nats")}}
+NATS_URL=nats://127.0.0.1:4222
+{{/if}}
+{{#if (includes microservices "rabbitmq")}}
+RABBITMQ_URL=amqp://127.0.0.1:5672
+{{/if}}
+{{#if (includes microservices "kafka")}}
+KAFKA_BROKER=127.0.0.1:9092
+{{/if}}
+{{#if (includes microservices "grpc")}}
+GRPC_URL=0.0.0.0:5000
+{{/if}}
 {{#if hasGraphql}}
 GRAPHQL_PLAYGROUND=true
 {{/if}}

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

@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+package app;
+
+service AppService {
+  rpc Ping (PingRequest) returns (PingResponse);
+}
+
+message PingRequest {}
+
+message PingResponse {
+  string message = 1;
+}

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

@@ -1,4 +1,5 @@
-import { Controller, EventPattern, MessagePattern } from "@nestjs/common";
+import { Controller, Get } from "@nestjs/common";
+import { EventPattern, {{#if (includes microservices "grpc")}}GrpcMethod{{else}}MessagePattern{{/if}} } from "@nestjs/microservices";
 
 import { AppService } from "./app.service.js";
 
@@ -6,10 +7,22 @@ import { AppService } from "./app.service.js";
 export class AppController {
   constructor(private readonly appService: AppService) {}
 
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+
+  {{#if (includes microservices "grpc")}}
+  @GrpcMethod("AppService", "Ping")
+  handleGrpcPing(): { message: string } {
+    return { message: this.appService.handlePing() };
+  }
+  {{else}}
   @MessagePattern("ping")
   handlePing(): string {
     return this.appService.handlePing();
   }
+  {{/if}}
 
   @EventPattern("log")
   handleLog(data: Record<string, unknown>): void {

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

@@ -9,6 +9,10 @@ export class AppService {
   constructor(private readonly db: DbService) {}
 
   {{/if}}
+  getHello(): string {
+    return "Hello World!";
+  }
+
   handlePing(): string {
     return "pong";
   }