@nest-arch/tui 0.2.8 → 0.4.3

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

@@ -1,4 +1,42 @@
+{{#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}}
+{{#if (and hasDatabase hasAuth)}}
+import { Injectable, NotFoundException } from "@nestjs/common";
+{{else}}
 import { Injectable } from "@nestjs/common";
+{{/if}}
 {{#if hasDatabase}}
 {{#if isMonorepo}}
 import { DbService } from "@repo/db";
@@ -7,8 +45,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 +75,163 @@ 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();
+{{#if hasMysql}}
+    const [inserted] = await this.db.drizzle.insert(schema.todos).values({ ...input, authorId }).$returningId();
+    if (!inserted) {
+      throw new NotFoundException("Todo not found");
+    }
+    const [todo] = await this.db.drizzle.select().from(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, inserted.id)));
+    return todo;
+{{else}}
+    const [todo] = await this.db.drizzle.insert(schema.todos).values({ ...input, authorId }).returning();
+    return todo;
+{{/if}}
 {{/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}}
+    const result = await ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).update(input);
+    if (!result) {
+      throw new NotFoundException("Todo not found");
+    }
+    return result;
+{{else if usePrisma}}
+    const todo = await this.db.prisma.todo.findFirst({ where: { authorId, id } });
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return this.db.prisma.todo.update({ data: input, where: { id } });
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).update({ authorId, id }, input);
+    const repository = this.db.typeorm.getRepository(Todo);
+    const result = await repository.update({ authorId, id }, input);
+    if (result.affected === 0) {
+      throw new NotFoundException("Todo not found");
+    }
+    const todo = await repository.findOneBy({ authorId, id });
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return todo;
 {{else if useDrizzle}}
-    return this.db.update(schema.todos).set(input).where(eq(schema.todos.authorId, authorId) && eq(schema.todos.id, id)).returning();
+{{#if hasMysql}}
+    await this.db.drizzle.update(schema.todos).set(input).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
+    const [todo] = await this.db.drizzle.select().from(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
+{{else}}
+    const [todo] = await this.db.drizzle.update(schema.todos).set(input).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id)))).returning();
+{{/if}}
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return todo;
 {{/if}}
   }
 
   async delete(id: string, authorId: string) {
-{{#if usePrisma}}
-    await this.db.prisma.todo.delete({ where: { authorId, id } });
+{{#if isPrisma8}}
+    const count = await ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).delete();
+    if (count === 0) {
+      throw new NotFoundException("Todo not found");
+    }
+{{else if usePrisma}}
+    const result = await this.db.prisma.todo.deleteMany({ where: { authorId, id } });
+    if (result.count === 0) {
+      throw new NotFoundException("Todo not found");
+    }
 {{else if useTypeorm}}
-    await this.db.getRepository(Todo).delete({ authorId, id });
+    const result = await this.db.typeorm.getRepository(Todo).delete({ authorId, id });
+    if (result.affected === 0) {
+      throw new NotFoundException("Todo not found");
+    }
 {{else if useDrizzle}}
-    await this.db.delete(schema.todos).where(eq(schema.todos.authorId, authorId) && eq(schema.todos.id, id));
+{{#if hasMysql}}
+    const [existing] = await this.db.drizzle.select().from(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
+    if (!existing) {
+      throw new NotFoundException("Todo not found");
+    }
+    await this.db.drizzle.delete(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
+{{else}}
+    const [todo] = await this.db.drizzle.delete(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id)))).returning();
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{/if}}
 {{/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 +265,5 @@ export class TodoService {
   }
 {{/if}}
 }
+
+{{/if}}

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

@@ -1,5 +1,5 @@
 {
-  "name": "{{projectName}}",
+  "name": "@repo/api-gateway",
   "version": "0.0.1",
   "private": true,
   "description": "{{description}}",
@@ -20,7 +20,7 @@
     "test:debug": "vitest --inspect-brk --no-file-parallelism",
     "test:e2e": "vitest run --config ./vitest.config.e2e.ts"{{#if hasUltracite}},
     "check": "ultracite check",
-    "fix": "ultracite fix"{{/if}}{{#if hasHusky}},
+    "fix": "ultracite fix --ignore-pattern migrations/**"{{/if}}{{#if hasHusky}},
     "prepare": "husky"{{/if}}
   },
   "dependencies": {
@@ -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,14 +1,19 @@
 // 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";
 {{#if (or hasDatabase hasOrm)}}
+{{#if isMonorepo}}
+import type { ISqlAdapter } from "@repo/db";
+import { DbService } from "@repo/db";
+{{else}}
 import type { ISqlAdapter } from "./database/adapters/interfaces/db-adapter.interface.js";
 import { DbService } from "./database/db.service.js";
 {{/if}}
+{{/if}}
 
 {{#if (or hasDatabase hasOrm)}}
 const mockSqlAdapter: ISqlAdapter = {

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

@@ -1,4 +1,7 @@
 import { Controller, Get } from "@nestjs/common";
+{{#if (eq auth "better-auth")}}
+import { AllowAnonymous } from "@thallesp/nestjs-better-auth";
+{{/if}}
 {{#if swagger}}
 import { ApiOperation, ApiResponse, ApiTags } from "@nestjs/swagger";
 {{/if}}
@@ -16,6 +19,9 @@ export class AppController {
   @ApiOperation({ summary: "/api" })
   @ApiResponse({ status: 200, description: "Returns a hello world message" })
   {{/if}}
+  {{#if (eq auth "better-auth")}}
+  @AllowAnonymous()
+  {{/if}}
   @Get()
   getHello(): string {
     return this.appService.getHello();

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

@@ -1,7 +1,11 @@
 import { Module } from "@nestjs/common";
 {{#if (or hasDatabase hasOrm)}}
+{{#if isMonorepo}}
+import { DbModule } from "@repo/db";
+{{else}}
 import { DbModule } from "./database/db.module.js";
-import { env } from "./config/env.js";
+{{/if}}
+import { env } from "@repo/env/api-gateway";
 {{/if}}
 {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
 import { AuthModule } from "./auth/auth.module.js";
@@ -17,6 +21,13 @@ import { AppErrorHandler } from "./libs/trpc/error.handler.js";
 {{#if hasTrpcAndAuth}}
 import { AuthTRPCMiddleware } from "./libs/middlewares/auth.trpc.middleware.js";
 {{/if}}
+{{#if (and hasTrpc hasRateLimiting)}}
+import { RateLimitTRPCMiddleware } from "./libs/middlewares/rate-limit.trpc.middleware.js";
+{{/if}}
+{{/if}}
+{{#if hasRateLimiting}}
+import { APP_GUARD } from "@nestjs/core";
+import { ThrottlerGuard, ThrottlerModule } from "@nestjs/throttler";
 {{/if}}
 
 import { AppController } from "./app.controller.js";
@@ -51,8 +62,19 @@ import { AppService } from "./app.service.js";
     TRPCModule.forRoot({
       context: AppContext,
       onError: AppErrorHandler,
+      {{#if hasRateLimiting}}
+      globalMiddlewares: [RateLimitTRPCMiddleware],
+      {{/if}}
     }),
     {{/if}}
+    {{#if hasRateLimiting}}
+    ThrottlerModule.forRoot([
+      {
+        ttl: 60_000,
+        limit: 60,
+      },
+    ]),
+    {{/if}}
     {{#if (and hasTodoExample (or hasRest hasTrpc))}}
     TodoModule,
     {{/if}}
@@ -63,6 +85,9 @@ import { AppService } from "./app.service.js";
     {{#if hasTrpcAndAuth}}
     AuthTRPCMiddleware,
     {{/if}}
+    {{#if hasRateLimiting}}
+    RateLimitTRPCMiddleware,
+    {{/if}}
     AppContext,
     AppErrorHandler,
     AppRouter,
@@ -70,6 +95,12 @@ import { AppService } from "./app.service.js";
     TodoRouter,
     {{/if}}
     {{/if}}
+    {{#if hasRateLimiting}}
+    {
+      provide: APP_GUARD,
+      useClass: ThrottlerGuard,
+    },
+    {{/if}}
   ],
 })
 export class AppModule {}

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

@@ -1,6 +1,6 @@
 import { Injectable } from "@nestjs/common";
 {{#if (or hasDatabase hasOrm)}}
-import { DbService } from "./database/db.service.js";
+import { DbService } from "@repo/db";
 {{/if}}
 
 @Injectable()

package/dist/templates/monorepo/apps/api-gateway/src/main.ts.hbs

@@ -16,11 +16,20 @@ import { apiReference } from "@scalar/nestjs-api-reference";
 import { SwaggerModule } from "@nestjs/swagger";
 {{/if}}
 {{#if (and swagger (or (eq auth "better-auth") (eq auth "better-auth:stateless")))}}
-import { auth } from "./auth/auth.js";
+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,
   });
@@ -38,7 +47,7 @@ async function bootstrap() {
           integrations: {
             {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
             betterAuth: {
-              auth,
+              auth: app.get(AuthService).instance,
               pathPrefix: "/api/auth",
             },
             {{/if}}
@@ -65,7 +74,7 @@ async function bootstrap() {
       integrations: {
         {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
         betterAuth: {
-          auth,
+          auth: app.get(AuthService).instance,
           pathPrefix: "/api/auth",
         },
         {{/if}}

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, expect, it } from "vitest";
 import type { App } from "supertest/types";
 
 import { AppModule } from "./../src/app.module.js";
@@ -13,15 +17,55 @@ 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);
+  });
+
+  {{#if (eq auth "better-auth")}}
+  it("creates a user and resolves the authenticated session", async () => {
+    const email = `monorepo-${Date.now()}@example.com`;
+    const signup = await request(app.getHttpServer())
+      .post("/api/auth/sign-up/email")
+      .set("origin", "http://localhost:3000")
+      .send({ email, name: "Monorepo Scenario", password: "Scenario-password-123!" })
+      .expect(200);
+    const cookies = (signup.headers["set-cookie"] ?? []).map((cookie) => cookie.split(";")[0]);
+    expect(cookies.length).toBeGreaterThan(0);
+
+    const session = await request(app.getHttpServer())
+      .get("/api/auth/get-session")
+      .set("cookie", cookies.join("; "))
+      .expect(200);
+    expect(session.body.user.email).toBe(email);
+
+    const profile = await request(app.getHttpServer())
+      .get("/auth-profile")
+      .set("cookie", cookies.join("; "))
+      .expect(200);
+    expect(profile.body).toEqual({ id: session.body.user.id, email });
+  });
+  {{/if}}
+
   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/graphql.module.ts.hbs

@@ -1,13 +1,10 @@
 import { Module } from "@nestjs/common";
 import { GraphQLModule } from "@nestjs/graphql";
 import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";
-import { join } from "path";
+import type { IncomingMessage } from "node:http";
+import path from "node:path";
 import { env } from "@repo/env/api-gateway";
-{{#if (eq httpProvider "fastify")}}
-// WARNING: If you use @as-integrations/fastify with multiple GraphQL endpoints
-// in a single application, make sure to enable the disableHealthCheck setting
-// in the GraphQLModule configuration below.
-{{/if}}
+import { HealthResolver } from "./resolvers/health.resolver.js";
 {{#if hasTodoExample}}
 import { TodoResolver } from "./resolvers/todo.resolver.js";
 {{/if}}
@@ -16,15 +13,14 @@ import { TodoResolver } from "./resolvers/todo.resolver.js";
   imports: [
     GraphQLModule.forRoot<ApolloDriverConfig>({
       driver: ApolloDriver,
-      autoSchemaFile: join(process.cwd(), "apps/api-gateway/src/schema.gql"),
+      autoSchemaFile: path.join(process.cwd(), "apps/api-gateway/src/schema.gql"),
       graphiql: env.GRAPHQL_PLAYGROUND,
+      context: ({ req, res }: { req: IncomingMessage; res: unknown }) => ({ req, res }),
       sortSchema: true,
-      {{#if (eq httpProvider "fastify")}}
-      disableHealthCheck: true,
-      {{/if}}
     }),
   ],
   providers: [
+    HealthResolver,
     {{#if hasTodoExample}}
     TodoResolver,
     {{/if}}

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

@@ -0,0 +1,14 @@
+import { Query, Resolver } from "@nestjs/graphql";
+{{#if isBetterAuth}}
+import { AllowAnonymous } from "@thallesp/nestjs-better-auth";
+{{/if}}
+{{#if isBetterAuth}}
+@AllowAnonymous()
+{{/if}}
+@Resolver()
+export class HealthResolver {
+  @Query(() => String)
+  hello(): string {
+    return "Hello GraphQL!";
+  }
+}