@nest-arch/tui 0.2.8 → 0.4.3

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

@@ -1,32 +1,76 @@
-{{#if (and hasAuth hasDatabase)}}
-import { UseGuards } from "@nestjs/common";
-{{/if}}
+{{#if (and usePrisma (eq auth "none"))}}
+import { BadRequestException, NotFoundException } from "@nestjs/common";
 import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { DbService } from "../../database/db.service.js";
+import { CreateTodoInput } from "../dto/create-todo.input.js";
+import { UpdateTodoInput } from "../dto/update-todo.input.js";
+import { Todo } from "../models/todo.model.js";
+
+@Resolver(() => Todo)
+export class TodoResolver {
+  constructor(private readonly db: DbService) {}
+
+  @Query(() => [Todo])
+  todos() {
+    return this.db.prisma.todo.findMany({ orderBy: { createdAt: "asc" }, take: 100 });
+  }
+
+  @Mutation(() => Todo)
+  createTodo(@Args("input") input: CreateTodoInput) {
+    if (!input.title.trim()) throw new BadRequestException("Title must not be empty");
+    return this.db.prisma.todo.create({ data: input });
+  }
+
+  @Mutation(() => Todo)
+  async updateTodo(@Args("input") input: UpdateTodoInput) {
+    const { id, ...data } = input;
+    if (data.title !== undefined && !data.title.trim()) throw new BadRequestException("Title must not be empty");
+    const result = await this.db.prisma.todo.updateManyAndReturn({ where: { id }, data });
+    if (!result[0]) throw new NotFoundException("Todo not found");
+    return result[0];
+  }
+
+  @Mutation(() => Boolean)
+  async deleteTodo(@Args("id") id: string): Promise<boolean> {
+    const result = await this.db.prisma.todo.deleteMany({ where: { id } });
+    if (result.count === 0) throw new NotFoundException("Todo not found");
+    return true;
+  }
+}
+{{else}}
 {{#if (and hasAuth hasDatabase)}}
+import { BadRequestException, NotFoundException, UseGuards } from "@nestjs/common";
 import { UserEntity } from "../../auth/decorators/index.js";
 import { GqlAuthGuard } from "../../auth/guards/gql-auth.guard.js";
+{{else}}
+import { BadRequestException, NotFoundException } from "@nestjs/common";
+{{/if}}
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+{{#if (and hasDatabase useTypeorm)}}
+import { GraphQLResolveInfo } from "graphql";
+import { GraphRelationBuilder } from "typeorm-relations-graphql";
+import { Todo as TodoEntity } from "../../database/entities/todo.entity.js";
+{{/if}}
+{{#if (and hasDatabase useDrizzle)}}
+import { and, eq } from "drizzle-orm";
+import * as schema from "../../database/orm/drizzle/schema.js";
 {{/if}}
+{{#if hasDatabase}}
 {{#if isMonorepo}}
 import { DbService } from "@repo/db";
 {{else}}
 import { DbService } from "../../database/db.service.js";
 {{/if}}
+{{/if}}
 import { CreateTodoInput } from "../dto/create-todo.input.js";
 import { UpdateTodoInput } from "../dto/update-todo.input.js";
-{{#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";
-{{/if}}
 
 @Resolver(() => Todo)
 export class TodoResolver {
+{{#if hasDatabase}}
   constructor(private readonly db: DbService) {}
+{{/if}}
 
   @Query(() => String)
   hello(): string {
@@ -34,87 +78,206 @@ export class TodoResolver {
   }{{#if hasDatabase}}
 
   @Query(() => [Todo])
-  todos({{#if useTypeorm}}info: GraphQLResolveInfo{{/if}}) {
+  {{#if hasAuth}}
+  @UseGuards(GqlAuthGuard)
+  {{/if}}
+  todos({{#if useTypeorm}}info: GraphQLResolveInfo, {{/if}}{{#if hasAuth}}@UserEntity() user: { id: string }{{/if}}) {
     {{#if useTypeorm}}
-    const builder = new GraphRelationBuilder(this.db.getDataSource());
+    const builder = new GraphRelationBuilder(this.db.typeorm);
     const relations = builder.buildForQuery(Todo, info, "todos");
-    return this.db.getRepository(Todo).find({ relations });
+    {{#if hasAuth}}
+    return this.db.typeorm.getRepository(TodoEntity).find({ relations, where: { authorId: user.id } });
+    {{else}}
+    return this.db.typeorm.getRepository(TodoEntity).find({ relations });
+    {{/if}}
+    {{else if isPrisma8}}
+    {{#if hasAuth}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ authorId: user.id }).all();
+    {{else}}
+    return ((this.db.prisma.orm.public as any).Todo).all();
+    {{/if}}
     {{else if usePrisma}}
+    {{#if hasAuth}}
+    return this.db.prisma.todo.findMany({ where: { authorId: user.id } });
+    {{else}}
     return this.db.prisma.todo.findMany();
+    {{/if}}
     {{else if useDrizzle}}
-    return this.db.select().from(schema.todos);
+    {{#if hasAuth}}
+    return this.db.drizzle.select().from(schema.todos).where(eq(schema.todos.authorId, user.id));
+    {{else}}
+    return this.db.drizzle.select().from(schema.todos);
+    {{/if}}
     {{else}}
     return [];
     {{/if}}
   }
 
+  {{#if hasAuth}}
   @UseGuards(GqlAuthGuard)
+  {{/if}}
   @Mutation(() => Todo)
-  createTodo(
+  async createTodo(
+    {{#if hasAuth}}
     @UserEntity() user: { id: string },
+    {{/if}}
     @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);
-    const builder = new GraphRelationBuilder(this.db.getDataSource());
+    if (!input.title.trim()) throw new BadRequestException("Title must not be empty");
+    {{#if isPrisma8}}
+    {{#if hasAuth}}
+    return ((this.db.prisma.orm.public as any).Todo).create({ ...input, authorId: user.id });
+    {{else}}
+    return ((this.db.prisma.orm.public as any).Todo).create(input);
+    {{/if}}
+    {{else if usePrisma}}
+    {{#if hasAuth}}
+    const todo = await this.db.prisma.todo.create({ data: { ...input, authorId: user.id } });
+    {{else}}
+    const todo = await this.db.prisma.todo.create({ data: input });
+    {{/if}}
+    return todo;
+    {{else if useTypeorm}}
+    {{#if hasAuth}}
+    const entity = this.db.typeorm.getRepository(TodoEntity).create({ ...input, authorId: user.id });
+    {{else}}
+    const entity = this.db.typeorm.getRepository(TodoEntity).create(input);
+    {{/if}}
+    const saved = await this.db.typeorm.getRepository(TodoEntity).save(entity);
+    const builder = new GraphRelationBuilder(this.db.typeorm);
     const relations = builder.buildForQuery(Todo, info, "createTodo");
-    return this.db.getRepository(Todo).findOneOrFail({
-      where: { id: saved.id },
+    return this.db.typeorm.getRepository(TodoEntity).findOneOrFail({
       relations,
-    });
-    {{else if usePrisma}}
-    return this.db.prisma.todo.create({
-      data: { ...input, authorId: user.id },
+      where: { id: saved.id },
     });
     {{else if useDrizzle}}
-    const [todo] = await this.db.insert(schema.todos).values(input).returning();
+    {{#if hasMysql}}
+    const [inserted] = await this.db.drizzle.insert(schema.todos).values({{#if hasAuth}}{ ...input, authorId: user.id }{{else}}input{{/if}}).$returningId();
+    if (!inserted) throw new NotFoundException("Todo not found");
+    const [todo] = await this.db.drizzle.select().from(schema.todos).where({{#if hasAuth}}and(eq(schema.todos.authorId, user.id), eq(schema.todos.id, inserted.id)){{else}}eq(schema.todos.id, inserted.id){{/if}});
+    if (!todo) throw new NotFoundException("Todo not found");
     return todo;
     {{else}}
+    {{#if hasAuth}}
+    const [todo] = await this.db.drizzle.insert(schema.todos).values({ ...input, authorId: user.id }).returning();
+    {{else}}
+    const [todo] = await this.db.drizzle.insert(schema.todos).values(input).returning();
+    {{/if}}
+    if (!todo) throw new NotFoundException("Todo not found");
+    return todo;
+    {{/if}}
+    {{else}}
     return { id: "1", ...input };
     {{/if}}
   }
 
+  {{#if hasAuth}}
   @UseGuards(GqlAuthGuard)
+  {{/if}}
   @Mutation(() => Todo)
-  updateTodo(@Args("input") input: UpdateTodoInput{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}) {
+  async updateTodo(
+    {{#if hasAuth}}
+    @UserEntity() user: { id: string },
+    {{/if}}
+    @Args("input") input: UpdateTodoInput{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}
+  ) {
     const { id, ...data } = input;
-    {{#if useTypeorm}}
-    await this.db.getRepository(Todo).update(id, data);
-    const builder = new GraphRelationBuilder(this.db.getDataSource());
+    if (data.title !== undefined && !data.title.trim()) throw new BadRequestException("Title must not be empty");
+    {{#if isPrisma8}}
+    {{#if hasAuth}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ authorId: user.id, id }).update(data);
+    {{else}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ id }).update(data);
+    {{/if}}
+    {{else if usePrisma}}
+    {{#if hasAuth}}
+    const result = await this.db.prisma.todo.update({ data, where: { authorId: user.id, id } });
+    {{else}}
+    const result = await this.db.prisma.todo.update({ data, where: { id } });
+    {{/if}}
+    return result;
+    {{else if useTypeorm}}
+    {{#if hasAuth}}
+    const updateResult = await this.db.typeorm.getRepository(TodoEntity).update({ authorId: user.id, id }, data);
+    {{else}}
+    const updateResult = await this.db.typeorm.getRepository(TodoEntity).update(id, data);
+    {{/if}}
+    if ((updateResult.affected ?? 0) === 0) throw new NotFoundException("Todo not found");
+    const builder = new GraphRelationBuilder(this.db.typeorm);
     const relations = builder.buildForQuery(Todo, info, "updateTodo");
-    return this.db.getRepository(Todo).findOneOrFail({
-      where: { id },
+    return this.db.typeorm.getRepository(TodoEntity).findOneOrFail({
       relations,
+      where: { id },
     });
-    {{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();
+    {{#if hasMysql}}
+    await this.db.drizzle.update(schema.todos).set(data).where({{#if hasAuth}}and(eq(schema.todos.authorId, user.id), eq(schema.todos.id, Number(id))){{else}}eq(schema.todos.id, Number(id)){{/if}});
+    const [todo] = await this.db.drizzle.select().from(schema.todos).where({{#if hasAuth}}and(eq(schema.todos.authorId, user.id), eq(schema.todos.id, Number(id))){{else}}eq(schema.todos.id, Number(id)){{/if}});
+    {{else}}
+    {{#if hasAuth}}
+    const [todo] = await this.db.drizzle.update(schema.todos).set(data).where(and(eq(schema.todos.authorId, user.id), eq(schema.todos.id, Number(id)))).returning();
+    {{else}}
+    const [todo] = await this.db.drizzle.update(schema.todos).set(data).where(eq(schema.todos.id, Number(id))).returning();
+    {{/if}}
+    {{/if}}
+    if (!todo) throw new NotFoundException("Todo not found");
     return todo;
     {{else}}
     return { id, ...data };
     {{/if}}
   }
 
+  {{#if hasAuth}}
   @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;
+  async deleteTodo(
+    {{#if hasAuth}}
+    @UserEntity() user: { id: string },
+    {{/if}}
+    @Args("id") id: string
+  ): Promise<boolean> {
+    {{#if isPrisma8}}
+    {{#if hasAuth}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ authorId: user.id, id }).delete();
+    {{else}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ id }).delete();
+    {{/if}}
+    return true;
     {{else if usePrisma}}
-    await this.db.prisma.todo.delete({ where: { id } });
+    {{#if hasAuth}}
+    const result = await this.db.prisma.todo.deleteMany({ where: { authorId: user.id, id } });
+    {{else}}
+    const result = await this.db.prisma.todo.deleteMany({ where: { id } });
+    {{/if}}
+    if (result.count === 0) throw new NotFoundException("Todo not found");
+    return true;
+    {{else if useTypeorm}}
+    {{#if hasAuth}}
+    const result = await this.db.typeorm.getRepository(TodoEntity).delete({ authorId: user.id, id });
+    {{else}}
+    const result = await this.db.typeorm.getRepository(TodoEntity).delete(id);
+    {{/if}}
+    if ((result.affected ?? 0) === 0) throw new NotFoundException("Todo not found");
     return true;
     {{else if useDrizzle}}
-    await this.db.delete(schema.todos).where(eq(schema.todos.id, id));
+    {{#if hasMysql}}
+    const [existing] = await this.db.drizzle.select().from(schema.todos).where({{#if hasAuth}}and(eq(schema.todos.authorId, user.id), eq(schema.todos.id, Number(id))){{else}}eq(schema.todos.id, Number(id)){{/if}});
+    if (!existing) throw new NotFoundException("Todo not found");
+    await this.db.drizzle.delete(schema.todos).where({{#if hasAuth}}and(eq(schema.todos.authorId, user.id), eq(schema.todos.id, Number(id))){{else}}eq(schema.todos.id, Number(id)){{/if}});
+    {{else}}
+    {{#if hasAuth}}
+    const deleted = await this.db.drizzle.delete(schema.todos).where(and(eq(schema.todos.authorId, user.id), eq(schema.todos.id, Number(id)))).returning();
+    {{else}}
+    const deleted = await this.db.drizzle.delete(schema.todos).where(eq(schema.todos.id, Number(id))).returning();
+    {{/if}}
+    if (deleted.length === 0) throw new NotFoundException("Todo not found");
+    {{/if}}
     return true;
     {{else}}
     return true;
     {{/if}}
   }{{/if}}
 }
+
+{{/if}}

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

@@ -1,5 +1,16 @@
 import { z } from "zod";
 
+{{#if (includes addons "nestjs-zod")}}
+import { createZodDto } from "nestjs-zod";
+
+const createTodoSchema = z.object({
+  completed: z.boolean().default(false),
+  description: z.string().optional(),
+  title: z.string().min(1),
+});
+
+export class CreateTodoDto extends createZodDto(createTodoSchema) {}
+{{else}}
 export class CreateTodoDto {
   static schema = z.object({
     completed: z.boolean().default(false),
@@ -11,3 +22,4 @@ export class CreateTodoDto {
   description?: string;
   completed: boolean;
 }
+{{/if}}

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

@@ -1,5 +1,16 @@
 import { z } from "zod";
 
+{{#if (includes addons "nestjs-zod")}}
+import { createZodDto } from "nestjs-zod";
+
+const updateTodoSchema = z.object({
+  completed: z.boolean().optional(),
+  description: z.string().optional(),
+  title: z.string().min(1).optional(),
+});
+
+export class UpdateTodoDto extends createZodDto(updateTodoSchema) {}
+{{else}}
 export class UpdateTodoDto {
   static schema = z.object({
     completed: z.boolean().optional(),
@@ -11,3 +22,4 @@ export class UpdateTodoDto {
   description?: string;
   completed?: boolean;
 }
+{{/if}}

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

@@ -9,6 +9,9 @@ import {
 {{#if (and isPassportAuth hasDatabase)}}
   UseGuards,
 {{/if}}
+{{#if (and isBetterAuth hasDatabase hasGraphql)}}
+  UseGuards,
+{{/if}}
 } from "@nestjs/common";
 {{#if swagger}}
 import {
@@ -16,10 +19,12 @@ import {
   ApiOkResponse,
   ApiOperation,
   ApiTags,
+{{#if (or isPassportAuth isBetterAuth)}}
   ApiUnauthorizedResponse,
+{{/if}}
 } from "@nestjs/swagger";
 {{/if}}
-{{#if isPassportAuth}}
+{{#if (and isPassportAuth swagger)}}
 import {
   ApiBearerAuth,
 } from "@nestjs/swagger";
@@ -32,6 +37,9 @@ import type { UserSession } from "../../auth/auth.js";
 import { RestAuthGuard } from "../../auth/guards/rest-auth.guard.js";
 import { CurrentUser } from "../../auth/decorators/current-user.decorator.js";
 {{/if}}
+{{#if (and isBetterAuth hasDatabase hasGraphql)}}
+import { RestAuthGuard } from "../../auth/guards/rest-auth.guard.js";
+{{/if}}
 import { TodoService } from "./todo.service.js";
 import { CreateTodoDto } from "./dto/create-todo.dto.js";
 import { UpdateTodoDto } from "./dto/update-todo.dto.js";
@@ -40,7 +48,7 @@ import { UpdateTodoDto } from "./dto/update-todo.dto.js";
 @ApiTags("Todos")
 {{/if}}
 @Controller("todos")
-{{#if (and isPassportAuth hasDatabase)}}
+{{#if (or (and isPassportAuth hasDatabase) (and isBetterAuth hasDatabase hasGraphql))}}
 @UseGuards(RestAuthGuard)
 {{/if}}
 export class TodoController {
@@ -62,7 +70,11 @@ export class TodoController {
     return this.todoService.findAll(user.id);
   }
 {{else if (and isBetterAuth hasDatabase)}}
+{{#if (and isMonorepo usePrisma)}}
+  findAll(@Session() session: UserSession): ReturnType<TodoService["findAll"]> {
+{{else}}
   findAll(@Session() session: UserSession) {
+{{/if}}
     return this.todoService.findAll(session.user.id);
   }
 {{else}}
@@ -84,20 +96,20 @@ export class TodoController {
 {{/if}}
 {{#if (and isPassportAuth hasDatabase)}}
   create(
-    @Body({ schema: CreateTodoDto.schema }) input: CreateTodoDto,
+    @Body{{#if (includes addons "nestjs-zod")}}(){{else}}({ schema: CreateTodoDto.schema }){{/if}} 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,
+    @Body{{#if (includes addons "nestjs-zod")}}(){{else}}({ schema: CreateTodoDto.schema }){{/if}} input: CreateTodoDto,
     @Session() session: UserSession
   ) {
     return this.todoService.create(input, session.user.id);
   }
 {{else}}
-  create(@Body({ schema: CreateTodoDto.schema }) input: CreateTodoDto) {
+  create(@Body{{#if (includes addons "nestjs-zod")}}(){{else}}({ schema: CreateTodoDto.schema }){{/if}} input: CreateTodoDto) {
     return this.todoService.create(input);
   }
 {{/if}}
@@ -116,7 +128,7 @@ export class TodoController {
 {{#if (and isPassportAuth hasDatabase)}}
   update(
     @Param("id") id: string,
-    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto,
+    @Body{{#if (includes addons "nestjs-zod")}}(){{else}}({ schema: UpdateTodoDto.schema }){{/if}} input: UpdateTodoDto,
     @CurrentUser() user: { id: string }
   ) {
     return this.todoService.update(id, input, user.id);
@@ -124,7 +136,7 @@ export class TodoController {
 {{else if (and isBetterAuth hasDatabase)}}
   update(
     @Param("id") id: string,
-    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto,
+    @Body{{#if (includes addons "nestjs-zod")}}(){{else}}({ schema: UpdateTodoDto.schema }){{/if}} input: UpdateTodoDto,
     @Session() session: UserSession
   ) {
     return this.todoService.update(id, input, session.user.id);
@@ -132,7 +144,7 @@ export class TodoController {
 {{else}}
   update(
     @Param("id") id: string,
-    @Body({ schema: UpdateTodoDto.schema }) input: UpdateTodoDto
+    @Body{{#if (includes addons "nestjs-zod")}}(){{else}}({ schema: UpdateTodoDto.schema }){{/if}} input: UpdateTodoDto
   ) {
     return this.todoService.update(id, input);
   }
@@ -164,7 +176,7 @@ export class TodoController {
     return this.todoService.delete(id, session.user.id);
   }
 {{else}}
-  async delete(@Param("id") id: string) {
+  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

@@ -11,14 +11,12 @@ import { TodoRouter } from "./todo.router.js";
   {{#if hasRest}}
   controllers: [TodoController],
   {{/if}}
+  exports: [TodoService],
   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

@@ -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}}
 }