@nest-arch/tui 0.2.0 → 0.2.2

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

@@ -0,0 +1,126 @@
+{{#if (and hasAuth hasDatabase)}}
+import { UseGuards } from "@nestjs/common";
+{{/if}}
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { CreateTodoInput } from "../dto/create-todo.input.js";
+import { UpdateTodoInput } from "../dto/update-todo.input.js";
+{{#if isMonorepo}}
+import { DbService } from "@repo/db";
+{{else}}
+import { DbService } from "../database/db.service.js";
+{{/if}}
+{{#if useTypeorm}}
+import { GraphRelationBuilder } from "typeorm-relations-graphql";
+import { GraphQLResolveInfo } from "graphql";
+{{/if}}
+{{#if useDrizzle}}
+import * as schema from "../database/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}})
+export class TodoResolver {
+  constructor(private readonly db: DbService) {}
+
+  @Query(() => String)
+  hello(): string {
+    return "Hello GraphQL!";
+  }{{#if hasDatabase}}
+
+  @Query(() => [Todo])
+  todos({{#if useTypeorm}}info: GraphQLResolveInfo{{/if}}): Promise<Todo[]> {
+    {{#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 usePrisma}}
+    return this.db.prisma.todo.findMany();
+    {{else if useDrizzle}}
+    return this.db.select().from(schema.todos);
+    {{else}}
+    return [];
+    {{/if}}
+  }
+
+  @Mutation(() => Todo)
+  {{#if (and hasAuth hasDatabase)}}
+  @UseGuards(GqlAuthGuard)
+  {{/if}}
+  createTodo(
+    @Args("input") input: CreateTodoInput{{#if (and hasAuth hasDatabase)}},
+    @UserEntity() user: { id: string }{{/if}}{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}
+  ): Promise<Todo> {
+    {{#if useTypeorm}}
+    const entity = this.db.getRepository(Todo).create(input);
+    const saved = await this.db.getRepository(Todo).save(entity);
+    const builder = new GraphRelationBuilder(this.db.getDataSource());
+    const relations = builder.buildForQuery(Todo, info, "createTodo");
+    return this.db.getRepository(Todo).findOneOrFail({
+      where: { id: saved.id },
+      relations,
+    });
+    {{else if usePrisma}}
+    return this.db.prisma.todo.create({
+      data: { ...input{{#if (and hasAuth hasDatabase)}}, authorId: user.id{{/if}} },
+    });
+    {{else if useDrizzle}}
+    const [todo] = await this.db.insert(schema.todos).values(input).returning();
+    return todo;
+    {{else}}
+    return { id: "1", ...input };
+    {{/if}}
+  }
+
+  @Mutation(() => Todo)
+  {{#if (and hasAuth hasDatabase)}}
+  @UseGuards(GqlAuthGuard)
+  {{/if}}
+  updateTodo(
+    @Args("input") input: UpdateTodoInput{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}
+  ): Promise<Todo> {
+    const { id, ...data } = input;
+    {{#if useTypeorm}}
+    await this.db.getRepository(Todo).update(id, data);
+    const builder = new GraphRelationBuilder(this.db.getDataSource());
+    const relations = builder.buildForQuery(Todo, info, "updateTodo");
+    return this.db.getRepository(Todo).findOneOrFail({
+      where: { id },
+      relations,
+    });
+    {{else if usePrisma}}
+    return this.db.prisma.todo.update({ where: { id }, data });
+    {{else if useDrizzle}}
+    const [todo] = await this.db
+      .update(schema.todos)
+      .set(data)
+      .where(eq(schema.todos.id, id))
+      .returning();
+    return todo;
+    {{else}}
+    return { id, ...data };
+    {{/if}}
+  }
+
+  @Mutation(() => Boolean)
+  {{#if (and hasAuth hasDatabase)}}
+  @UseGuards(GqlAuthGuard)
+  {{/if}}
+  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 usePrisma}}
+    await this.db.prisma.todo.delete({ where: { id } });
+    return true;
+    {{else if useDrizzle}}
+    await this.db.delete(schema.todos).where(eq(schema.todos.id, id));
+    return true;
+    {{else}}
+    return true;
+    {{/if}}
+  }{{/if}}
+}

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export class CreateTodoDto {
+  static schema = z.object({
+    completed: z.boolean().default(false),
+    description: z.string().optional(),
+    title: z.string().min(1),
+  });
+
+  title: string;
+  description?: string;
+  completed: boolean;
+}

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export class UpdateTodoDto {
+  static schema = z.object({
+    completed: z.boolean().optional(),
+    description: z.string().optional(),
+    title: z.string().min(1).optional(),
+  });
+
+  title?: string;
+  description?: string;
+  completed?: boolean;
+}

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

@@ -0,0 +1,171 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Put,
+{{#if (and isPassportAuth hasDatabase)}}
+  UseGuards,
+{{/if}}
+} from "@nestjs/common";
+{{#if swagger}}
+import {
+  ApiCreatedResponse,
+  ApiOkResponse,
+  ApiOperation,
+  ApiTags,
+  ApiUnauthorizedResponse,
+} from "@nestjs/swagger";
+{{/if}}
+{{#if isPassportAuth}}
+import {
+  ApiBearerAuth,
+} from "@nestjs/swagger";
+{{/if}}
+{{#if (and isBetterAuth hasDatabase)}}
+import { Session } from "@thallesp/nestjs-better-auth";
+import type { UserSession } from "../../auth/auth.js";
+{{/if}}
+{{#if (and isPassportAuth hasDatabase)}}
+import { RestAuthGuard } from "../../auth/guards/rest-auth.guard.js";
+import { CurrentUser } from "../../auth/decorators/current-user.decorator.js";
+{{/if}}
+import { TodoService } from "./todo.service.js";
+import { CreateTodoDto } from "./dto/create-todo.dto.js";
+import { UpdateTodoDto } from "./dto/update-todo.dto.js";
+
+{{#if swagger}}
+@ApiTags("Todos")
+{{/if}}
+@Controller("todos")
+{{#if (and isPassportAuth hasDatabase)}}
+@UseGuards(RestAuthGuard)
+{{/if}}
+export class TodoController {
+  constructor(private readonly todoService: TodoService) {}
+
+  @Get()
+{{#if swagger}}
+{{#if (or isPassportAuth)}}
+  @ApiBearerAuth()
+{{/if}}
+  @ApiOperation({ summary: "/api/todos" })
+  @ApiOkResponse({ description: "Returns all todos" })
+{{#if (or isPassportAuth isBetterAuth)}}
+  @ApiUnauthorizedResponse({ description: "Unauthorized" })
+{{/if}}
+{{/if}}
+{{#if (and isPassportAuth hasDatabase)}}
+  findAll(@CurrentUser() user: { id: string }) {
+    return this.todoService.findAll(user.id);
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  findAll(@Session() session: UserSession) {
+    return this.todoService.findAll(session.user.id);
+  }
+{{else}}
+  findAll() {
+    return this.todoService.findAll();
+  }
+{{/if}}
+
+  @Post()
+{{#if swagger}}
+{{#if (or isPassportAuth)}}
+  @ApiBearerAuth()
+{{/if}}
+  @ApiOperation({ summary: "/api/todos" })
+  @ApiCreatedResponse({ description: "Todo created successfully" })
+{{#if (or isPassportAuth isBetterAuth)}}
+  @ApiUnauthorizedResponse({ description: "Unauthorized" })
+{{/if}}
+{{/if}}
+{{#if (and isPassportAuth hasDatabase)}}
+  create(
+    @Body({ schema: CreateTodoDto.schema }) input: CreateTodoDto,
+    @CurrentUser() user: { id: string }
+  ) {
+    return this.todoService.create(input, user.id);
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  create(
+    @Body({ schema: CreateTodoDto.schema }) input: CreateTodoDto,
+    @Session() session: UserSession
+  ) {
+    return this.todoService.create(input, session.user.id);
+  }
+{{else}}
+  create(@Body({ schema: CreateTodoDto.schema }) input: CreateTodoDto) {
+    return this.todoService.create(input);
+  }
+{{/if}}
+
+  @Put(":id")
+{{#if swagger}}
+{{#if (or isPassportAuth)}}
+  @ApiBearerAuth()
+{{/if}}
+  @ApiOperation({ summary: "/api/todos/{id}" })
+  @ApiOkResponse({ description: "Todo updated successfully" })
+{{#if (or isPassportAuth isBetterAuth)}}
+  @ApiUnauthorizedResponse({ description: "Unauthorized" })
+{{/if}}
+{{/if}}
+{{#if (and isPassportAuth hasDatabase)}}
+  update(
+    @Param("id") id: string,
+    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto,
+    @CurrentUser() user: { id: string }
+  ) {
+    return this.todoService.update(id, input, user.id);
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  update(
+    @Param("id") id: string,
+    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto,
+    @Session() session: UserSession
+  ) {
+    return this.todoService.update(id, input, session.user.id);
+  }
+{{else}}
+  update(
+    @Param("id") id: string,
+    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto
+  ) {
+    return this.todoService.update(id, input);
+  }
+{{/if}}
+
+  @Delete(":id")
+{{#if swagger}}
+{{#if (or isPassportAuth)}}
+  @ApiBearerAuth()
+{{/if}}
+  @ApiOperation({ summary: "/api/todos/{id}" })
+  @ApiOkResponse({ description: "Todo deleted successfully" })
+{{#if (or isPassportAuth isBetterAuth)}}
+  @ApiUnauthorizedResponse({ description: "Unauthorized" })
+{{/if}}
+{{/if}}
+{{#if (and isPassportAuth hasDatabase)}}
+  async delete(
+    @Param("id") id: string,
+    @CurrentUser() user: { id: string }
+  ) {
+    return this.todoService.delete(id, user.id);
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  async delete(
+    @Param("id") id: string,
+    @Session() session: UserSession
+  ) {
+    return this.todoService.delete(id, session.user.id);
+  }
+{{else}}
+  async delete(@Param("id") id: string) {
+    return this.todoService.delete(id);
+  }
+{{/if}}
+}

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

@@ -0,0 +1,24 @@
+import { Module } from "@nestjs/common";
+{{#if hasRest}}
+import { TodoController } from "./todo.controller.js";
+{{/if}}
+import { TodoService } from "./todo.service.js";
+{{#unless hasRest}}
+import { TodoRouter } from "./todo.router.js";
+{{/unless}}
+
+@Module({
+  {{#if hasRest}}
+  controllers: [TodoController],
+  {{/if}}
+  providers: [
+    TodoService,
+    {{#unless hasRest}}
+    TodoRouter,
+    {{/unless}}
+  ],
+  {{#if hasRest}}
+  exports: [TodoService],
+  {{/if}}
+})
+export class TodoModule {}

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

@@ -0,0 +1,76 @@
+{{#if hasTrpc}}
+import { Router, Query, Mutation, Ctx, Input } from "nestjs-trpc";
+import z from "zod";
+{{#if hasTrpcAndAuth}}
+import type { UserSession } from "../../auth/auth.js";
+import { AuthTRPCMiddleware } from "../../libs/middlewares/auth.trpc.middleware.js";
+import type { InnerContext } from "../../libs/trpc/inner.context.js";
+{{/if}}
+import { TodoService } from "./todo.service.js";
+import { CreateTodoDto } from "./dto/create-todo.dto.js";
+import { UpdateTodoDto } from "./dto/update-todo.dto.js";
+
+const todoSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().nullable().optional(),
+  completed: z.boolean(),
+  authorId: z.string().nullable().optional(),
+});
+
+const updateTodoInput = z.object({
+  id: z.string(),
+  data: UpdateTodoDto.schema,
+});
+
+@Router({ alias: "todoRouter" })
+export class TodoRouter {
+  constructor(private readonly todoService: TodoService) {}
+
+{{#if hasTrpcAndAuth}}
+  @Query({ output: z.array(todoSchema) })
+  @UseMiddlewares(AuthTRPCMiddleware)
+  findAll(@Ctx() ctx: InnerContext) {
+    return this.todoService.findAll(ctx.session!.user.id);
+  }
+
+  @Mutation({ input: CreateTodoDto.schema, output: todoSchema })
+  @UseMiddlewares(AuthTRPCMiddleware)
+  create(@Ctx() ctx: InnerContext, @Input() input: CreateTodoDto) {
+    return this.todoService.create(input, ctx.session!.user.id);
+  }
+
+  @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);
+  }
+
+  @Mutation({ input: z.object({ id: z.string() }) })
+  @UseMiddlewares(AuthTRPCMiddleware)
+  delete(@Ctx() ctx: InnerContext, @Input() input: { id: string }) {
+    return this.todoService.delete(input.id, ctx.session!.user.id);
+  }
+{{else}}
+  @Query({ output: z.array(todoSchema) })
+  findAll() {
+    return this.todoService.findAll();
+  }
+
+  @Mutation({ input: CreateTodoDto.schema, output: todoSchema })
+  create(@Input() input: CreateTodoDto) {
+    return this.todoService.create(input);
+  }
+
+  @Mutation({ input: updateTodoInput, output: todoSchema })
+  update(@Input() input: { id: string; data: UpdateTodoDto }) {
+    return this.todoService.update(input.id, input.data);
+  }
+
+  @Mutation({ input: z.object({ id: z.string() }) })
+  delete(@Input() input: { id: string }) {
+    return this.todoService.delete(input.id);
+  }
+{{/if}}
+}
+{{/if}}

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

@@ -0,0 +1,145 @@
+import { Injectable } from "@nestjs/common";
+{{#if hasDatabase}}
+{{#if isMonorepo}}
+import { DbService } from "@repo/db";
+{{else}}
+import { DbService } from "../../database/db.service.js";
+{{/if}}
+{{#if useDrizzle}}
+import * as schema from "../../database/orm/drizzle/schema.js";
+import { eq } from "drizzle-orm";
+{{/if}}
+{{#if useTypeorm}}
+import { Todo } from "../../database/entities/todo.entity.js";
+{{/if}}
+{{/if}}
+import { CreateTodoDto } from "./dto/create-todo.dto.js";
+import { UpdateTodoDto } from "./dto/update-todo.dto.js";
+
+@Injectable()
+export class TodoService {
+{{#if hasDatabase}}
+  constructor(private readonly db: DbService) {}
+{{else}}
+  private todos: Array<{
+    completed: boolean;
+    description?: string;
+    id: string;
+    title: string;
+  }> = [];
+  private nextId = 1;
+{{/if}}
+
+{{#if hasDatabase}}
+{{#if hasAuth}}
+  findAll(authorId: string) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.findMany({ where: { authorId } });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).find({ where: { authorId } });
+{{else if useDrizzle}}
+    return this.db.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 } });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).save(this.db.getRepository(Todo).create({ ...input, authorId }));
+{{else if useDrizzle}}
+    return this.db.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 } });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).update({ authorId, id }, input);
+{{else if useDrizzle}}
+    return this.db.update(schema.todos).set(input).where(eq(schema.todos.authorId, authorId) && eq(schema.todos.id, id)).returning();
+{{/if}}
+  }
+
+  async delete(id: string, authorId: string) {
+{{#if usePrisma}}
+    await this.db.prisma.todo.delete({ where: { authorId, id } });
+{{else if useTypeorm}}
+    await this.db.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));
+{{/if}}
+    return { message: "Todo deleted successfully" };
+  }
+{{else}}
+  findAll() {
+{{#if usePrisma}}
+    return this.db.prisma.todo.findMany();
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).find();
+{{else if useDrizzle}}
+    return this.db.select().from(schema.todos);
+{{/if}}
+  }
+
+  create(input: CreateTodoDto) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.create({ data: input });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).save(this.db.getRepository(Todo).create(input));
+{{else if useDrizzle}}
+    return this.db.insert(schema.todos).values(input).returning();
+{{/if}}
+  }
+
+  update(id: string, input: UpdateTodoDto) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.update({ data: input, where: { id } });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).update(id, input);
+{{else if useDrizzle}}
+    return this.db.update(schema.todos).set(input).where(eq(schema.todos.id, id)).returning();
+{{/if}}
+  }
+
+  async delete(id: string) {
+{{#if usePrisma}}
+    await this.db.prisma.todo.delete({ where: { id } });
+{{else if useTypeorm}}
+    await this.db.getRepository(Todo).delete(id);
+{{else if useDrizzle}}
+    await this.db.delete(schema.todos).where(eq(schema.todos.id, id));
+{{/if}}
+    return { message: "Todo deleted successfully" };
+  }
+{{/if}}
+{{else}}
+  findAll() {
+    return [...this.todos];
+  }
+
+  create(input: CreateTodoDto) {
+    const todo = { id: String(this.nextId++), ...input };
+    this.todos.push(todo);
+    return todo;
+  }
+
+  update(id: string, input: UpdateTodoDto) {
+    const todo = this.todos.find((t) => t.id === id);
+    if (!todo) {
+      return { message: "Todo not found" };
+    }
+    Object.assign(todo, input);
+    return todo;
+  }
+
+  async delete(id: string) {
+    const index = this.todos.findIndex((t) => t.id === id);
+    if (index >= 0) {
+      this.todos.splice(index, 1);
+    }
+    return { message: "Todo deleted successfully" };
+  }
+{{/if}}
+}

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

@@ -6,6 +6,9 @@ import { env } from "./config/env.js";
 {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
 import { AuthModule } from "./auth/auth.module.js";
 {{/if}}
+{{#if hasGraphql}}
+import { GraphqlAppModule } from "./graphql/graphql.module.js";
+{{/if}}
 {{#if hasTrpc}}
 import { TRPCModule } from "nestjs-trpc";
 import { AppRouterClass as AppRouter } from "./app.router.js";
@@ -17,10 +20,18 @@ import { AuthTRPCMiddleware } from "./libs/middlewares/auth.trpc.middleware.js";
 {{/if}}
 
 import { AppController } from "./app.controller.js";
+{{#if (and hasTodoExample (or hasRest hasTrpc))}}
+import { TodoModule } from "./api/todo/todo.module.js";
+{{/if}}
+{{#if (and hasTrpc hasTodoExample hasRest)}}
+import { TodoRouter } from "./api/todo/todo.router.js";
+{{/if}}
 import { AppService } from "./app.service.js";
 
 @Module({
-  controllers: [AppController],
+  controllers: [
+    AppController,
+  ],
   imports: [
     {{#if (or hasDatabase hasOrm)}}
     DbModule.forRoot({
@@ -33,12 +44,18 @@ import { AppService } from "./app.service.js";
     {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
     AuthModule,
     {{/if}}
+    {{#if hasGraphql}}
+    GraphqlAppModule,
+    {{/if}}
     {{#if hasTrpc}}
     TRPCModule.forRoot({
       context: AppContext,
       onError: AppErrorHandler,
     }),
     {{/if}}
+    {{#if (and hasTodoExample (or hasRest hasTrpc))}}
+    TodoModule,
+    {{/if}}
   ],
   providers: [
     AppService,
@@ -49,6 +66,9 @@ import { AppService } from "./app.service.js";
     AppContext,
     AppErrorHandler,
     AppRouter,
+    {{#if (and hasTrpc hasTodoExample hasRest)}}
+    TodoRouter,
+    {{/if}}
     {{/if}}
   ],
 })