@nest-arch/tui 0.4.0 → 0.4.3

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

@@ -1,8 +1,12 @@
 {{#if hasTrpc}}
-import { Router, Query, Mutation, Ctx, Input } from "nestjs-trpc";
+import { Router, Query, Mutation, Ctx, Input{{#if hasTrpcAndAuth}}, UseMiddlewares{{/if}} } from "nestjs-trpc";
+import { NotFoundException } from "@nestjs/common";
+import { TRPCError } from "@trpc/server";
 import z from "zod";
-{{#if hasTrpcAndAuth}}
+{{#if (and hasTrpcAndAuth isBetterAuth)}}
 import type { UserSession } from "../../auth/auth.js";
+{{/if}}
+{{#if hasTrpcAndAuth}}
 import { AuthTRPCMiddleware } from "../../libs/middlewares/auth.trpc.middleware.js";
 import type { InnerContext } from "../../libs/trpc/inner.context.js";
 {{/if}}
@@ -11,7 +15,7 @@ import { CreateTodoDto } from "./dto/create-todo.dto.js";
 import { UpdateTodoDto } from "./dto/update-todo.dto.js";
 
 const todoSchema = z.object({
-  id: z.string(),
+  id: z.union([z.string(), z.number()]),
   title: z.string(),
   description: z.string().nullable().optional(),
   completed: z.boolean(),
@@ -19,7 +23,7 @@ const todoSchema = z.object({
 });
 
 const updateTodoInput = z.object({
-  id: z.string(),
+  id: z.union([z.string(), z.number()]),
   data: UpdateTodoDto.schema,
 });
 
@@ -42,14 +46,26 @@ export class TodoRouter {
 
   @Mutation({ input: updateTodoInput, output: todoSchema })
   @UseMiddlewares(AuthTRPCMiddleware)
-  update(@Ctx() ctx: InnerContext, @Input() input: { id: string; data: UpdateTodoDto }) {
-    return this.todoService.update(input.id, input.data, ctx.session!.user.id);
+  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;
+      });
   }
 
-  @Mutation({ input: z.object({ id: z.string() }) })
+  @Mutation({ input: z.object({ id: z.union([z.string(), z.number()]) }) })
   @UseMiddlewares(AuthTRPCMiddleware)
-  delete(@Ctx() ctx: InnerContext, @Input() input: { id: string }) {
-    return this.todoService.delete(input.id, ctx.session!.user.id);
+  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;
+      });
   }
 {{else}}
   @Query({ output: z.array(todoSchema) })
@@ -64,12 +80,24 @@ export class TodoRouter {
 
   @Mutation({ input: updateTodoInput, output: todoSchema })
   update(@Input() input: { id: string; data: UpdateTodoDto }) {
-    return this.todoService.update(input.id, input.data);
+    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;
+      });
   }
 
-  @Mutation({ input: z.object({ id: z.string() }) })
-  delete(@Input() input: { id: string }) {
-    return this.todoService.delete(input.id);
+  @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;
+      });
   }
 {{/if}}
 }

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

@@ -32,7 +32,11 @@ export class TodoService {
   }
 }
 {{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";
@@ -92,33 +96,87 @@ export class TodoService {
     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.drizzle.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}}
   }
 
   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 } });
+    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}}
-    const result = await this.db.typeorm.getRepository(Todo).update({ authorId, id }, input);
-    return result;
+    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.drizzle.update(schema.todos).set(input).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(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 isPrisma8}}
-    await ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).delete();
+    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}}
-    await this.db.prisma.todo.delete({ where: { authorId, id } });
+    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.typeorm.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}}
+{{#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" };
   }

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": {

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

@@ -6,9 +6,14 @@ import { beforeEach, describe, expect, it{{#if (or hasDatabase hasOrm)}}, vi{{/i
 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

@@ -4,7 +4,7 @@ import { Test, TestingModule } from "@nestjs/testing";
 import { FastifyAdapter } from "@nestjs/platform-fastify";
 {{/if}}
 import request from "supertest";
-import { afterEach, beforeEach, describe, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import type { App } from "supertest/types";
 
 import { AppModule } from "./../src/app.module.js";
@@ -40,6 +40,31 @@ describe("AppController (e2e)", () => {
     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();
   });

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!";
+  }
+}