@nest-arch/tui 0.1.48 → 0.2.1

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,346 @@
+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 isMonorepo}}
+import { DbService } from "@repo/db";
+{{else if hasDatabase}}
+import { DbService } from "../../database/db.service.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}}
+{{#if hasDatabase}}
+{{#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";
+
+{{#if swagger}}
+@ApiTags("Todos")
+{{/if}}
+@Controller("todos")
+{{#if (and isPassportAuth hasDatabase)}}
+@UseGuards(RestAuthGuard)
+{{/if}}
+export class TodoController {
+{{#if hasDatabase}}
+  constructor(private readonly db: DbService) {}
+{{else}}
+  private todos: Array<{
+    completed: boolean;
+    description?: string;
+    id: string;
+    title: string;
+  }> = [];
+  private nextId = 1;
+{{/if}}
+
+  @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 }) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.findMany({ where: { authorId: user.id } });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).find({ where: { authorId: user.id } });
+{{else if useDrizzle}}
+    return this.db
+      .select()
+      .from(schema.todos)
+      .where(eq(schema.todos.authorId, user.id));
+{{/if}}
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  findAll(@Session() session: UserSession) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.findMany({
+      where: { authorId: session.user.id },
+    });
+{{else if useTypeorm}}
+    return this.db
+      .getRepository(Todo)
+      .find({ where: { authorId: session.user.id } });
+{{else if useDrizzle}}
+    return this.db
+      .select()
+      .from(schema.todos)
+      .where(eq(schema.todos.authorId, session.user.id));
+{{/if}}
+  }
+{{else if hasDatabase}}
+  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}}
+  }
+{{else}}
+  findAll() {
+    return [...this.todos];
+  }
+{{/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 }
+  ) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.create({
+      data: { ...input, authorId: user.id },
+    });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).save(
+      this.db.getRepository(Todo).create({ ...input, authorId: user.id }),
+    );
+{{else if useDrizzle}}
+    return this.db
+      .insert(schema.todos)
+      .values({ ...input, authorId: user.id })
+      .returning();
+{{/if}}
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  create(
+    @Body({ schema: CreateTodoDto.schema }) input: CreateTodoDto,
+    @Session() session: UserSession
+  ) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.create({
+      data: { ...input, authorId: session.user.id },
+    });
+{{else if useTypeorm}}
+    return this.db.getRepository(Todo).save(
+      this.db
+        .getRepository(Todo)
+        .create({ ...input, authorId: session.user.id }),
+    );
+{{else if useDrizzle}}
+    return this.db
+      .insert(schema.todos)
+      .values({ ...input, authorId: session.user.id })
+      .returning();
+{{/if}}
+  }
+{{else if hasDatabase}}
+  create(@Body({ schema: CreateTodoDto.schema }) 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}}
+  }
+{{else}}
+  create(@Body({ schema: CreateTodoDto.schema }) input: CreateTodoDto) {
+    const todo = { id: String(this.nextId++), ...input };
+    this.todos.push(todo);
+    return todo;
+  }
+{{/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 }
+  ) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.update({
+      data: input,
+      where: { authorId: user.id, id },
+    });
+{{else if useTypeorm}}
+    return this.db
+      .getRepository(Todo)
+      .update({ authorId: user.id, id }, input);
+{{else if useDrizzle}}
+    return this.db
+      .update(schema.todos)
+      .set(input)
+      .where(
+        eq(schema.todos.authorId, user.id) && eq(schema.todos.id, id),
+      )
+      .returning();
+{{/if}}
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  update(
+    @Param("id") id: string,
+    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto,
+    @Session() session: UserSession
+  ) {
+{{#if usePrisma}}
+    return this.db.prisma.todo.update({
+      data: input,
+      where: { authorId: session.user.id, id },
+    });
+{{else if useTypeorm}}
+    return this.db
+      .getRepository(Todo)
+      .update({ authorId: session.user.id, id }, input);
+{{else if useDrizzle}}
+    return this.db
+      .update(schema.todos)
+      .set(input)
+      .where(
+        eq(schema.todos.authorId, session.user.id) &&
+          eq(schema.todos.id, id),
+      )
+      .returning();
+{{/if}}
+  }
+{{else if hasDatabase}}
+  update(
+    @Param("id") id: string,
+    @Body({ schema: UpdateTodoDto.schema }) 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}}
+  }
+{{else}}
+  update(
+    @Param("id") id: string,
+    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto
+  ) {
+    const todo = this.todos.find((t) => t.id === id);
+    if (!todo) {
+      return { message: "Todo not found" };
+    }
+    Object.assign(todo, input);
+    return todo;
+  }
+{{/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 }
+  ) {
+    await this.db.prisma.todo.delete({
+      where: { authorId: user.id, id },
+    });
+    return { message: "Todo deleted successfully" };
+  }
+{{else if (and isBetterAuth hasDatabase)}}
+  async delete(
+    @Param("id") id: string,
+    @Session() session: UserSession
+  ) {
+    await this.db.prisma.todo.delete({
+      where: { authorId: session.user.id, id },
+    });
+    return { message: "Todo deleted successfully" };
+  }
+{{else if hasDatabase}}
+  async delete(@Param("id") 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" };
+  }
+{{else}}
+  async delete(@Param("id") 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.controller.ts.hbs

@@ -1,11 +1,21 @@
 import { Controller, Get } from "@nestjs/common";
+{{#if swagger}}
+import { ApiOperation, ApiResponse, ApiTags } from "@nestjs/swagger";
+{{/if}}
 
 import { AppService } from "./app.service.js";
 
+{{#if swagger}}
+@ApiTags("App")
+{{/if}}
 @Controller()
 export class AppController {
   constructor(private readonly appService: AppService) {}
 
+  {{#if swagger}}
+  @ApiOperation({ summary: "/api" })
+  @ApiResponse({ status: 200, description: "Returns a hello world message" })
+  {{/if}}
   @Get()
   getHello(): string {
     return this.appService.getHello();

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

@@ -6,12 +6,32 @@ 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";
+import { AppContext } from "./libs/trpc/context.js";
+import { AppErrorHandler } from "./libs/trpc/error.handler.js";
+{{#if hasTrpcAndAuth}}
+import { AuthTRPCMiddleware } from "./libs/middlewares/auth.trpc.middleware.js";
+{{/if}}
+{{/if}}
 
 import { AppController } from "./app.controller.js";
+{{#if (and hasTodoExample hasRest)}}
+import { TodoController } from "./api/todo/todo.controller.js";
+{{/if}}
 import { AppService } from "./app.service.js";
 
 @Module({
-  controllers: [AppController],
+  controllers: [
+    AppController,
+    {{#if (and hasTodoExample hasRest)}}
+    TodoController,
+    {{/if}}
+  ],
   imports: [
     {{#if (or hasDatabase hasOrm)}}
     DbModule.forRoot({
@@ -24,7 +44,26 @@ 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}}
+  ],
+  providers: [
+    AppService,
+    {{#if hasTrpc}}
+    {{#if hasTrpcAndAuth}}
+    AuthTRPCMiddleware,
+    {{/if}}
+    AppContext,
+    AppErrorHandler,
+    AppRouter,
+    {{/if}}
   ],
-  providers: [AppService],
 })
 export class AppModule {}

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

@@ -2,15 +2,90 @@ import { NestFactory } from "@nestjs/core";
 {{#if (eq httpProvider "fastify")}}
 import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
 {{/if}}
+import { Logger } from "@nestjs/common";
 import { env } from "@repo/env/api-gateway";
 
 import { AppModule } from "./app.module.js";
+{{#if swagger}}
+import { createDocs } from "./docs/create-docs.js";
+{{/if}}
+{{#if (and swagger useSwaggerScalar)}}
+import { apiReference } from "@scalar/nestjs-api-reference";
+{{/if}}
+{{#if (and swagger (eq useSwaggerScalar false))}}
+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";
+{{/if}}
 
 async function bootstrap() {
   const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter()){{else}}(AppModule){{/if}};
   app.enableCors({
     origin: env.CORS_ORIGIN,
   });
+  {{#if swagger}}
+  if (env.NODE_ENV === "development") {
+    const docsPath = "/docs";
+    {{#if useSwaggerScalar}}
+    app.use(
+      docsPath,
+      apiReference({
+        content: await createDocs(app, {
+          title: "{{projectNamePascalCase}} API",
+          description: "{{description}}",
+          version: "1.0.0",
+          integrations: {
+            {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+            betterAuth: {
+              auth,
+              pathPrefix: "/api/auth",
+            },
+            {{/if}}
+            {{#if (includes apis "trpc")}}
+            trpc: {
+              routerFilePath: "./src/libs/trpc/@generated/server.ts",
+              pathPrefix: "/trpc",
+            },
+            {{/if}}
+            zod: {
+              withFastify: {{#if (eq httpProvider "fastify")}}true{{else}}false{{/if}},
+            },
+          },
+        }),
+        pageTitle: "{{projectNamePascalCase}} API Docs",
+        theme: "default",
+      }),
+    );
+    {{else}}
+    const document = await createDocs(app, {
+      title: "{{projectNamePascalCase}} API",
+      description: "{{description}}",
+      version: "1.0.0",
+      integrations: {
+        {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+        betterAuth: {
+          auth,
+          pathPrefix: "/api/auth",
+        },
+        {{/if}}
+        {{#if (includes apis "trpc")}}
+        trpc: {
+          routerFilePath: "./src/trpc/router.ts",
+          pathPrefix: "/trpc",
+        },
+        {{/if}}
+        zod: {
+          withFastify: {{#if (eq httpProvider "fastify")}}true{{else}}false{{/if}},
+        },
+      },
+    });
+    SwaggerModule.setup(docsPath, app, document);
+    {{/if}}
+    Logger.log(`Swagger documentation available at http://localhost:${env.PORT ?? 3000}${docsPath}`, "SwaggerDocs");
+  }
+  {{/if}}
   await app.listen(env.PORT ?? 3000);
+  Logger.log(`Started backend server on http://localhost:${env.PORT ?? 3000}/api`, "Main");
 }
 await bootstrap();

package/dist/templates/monorepo/feature/graphql/src/graphql/dto/create-todo.input.ts.hbs

@@ -0,0 +1,13 @@
+import { Field, InputType } from "@nestjs/graphql";
+
+@InputType()
+export class CreateTodoInput {
+  @Field()
+  title: string;
+
+  @Field({ nullable: true })
+  description?: string;
+
+  @Field({ defaultValue: false })
+  completed: boolean;
+}

package/dist/templates/monorepo/feature/graphql/src/graphql/dto/update-todo.input.ts.hbs

@@ -0,0 +1,8 @@
+import { Field, ID, InputType, PartialType } from "@nestjs/graphql";
+import { CreateTodoInput } from "./create-todo.input.js";
+
+@InputType()
+export class UpdateTodoInput extends PartialType(CreateTodoInput) {
+  @Field(() => ID)
+  id: string;
+}