// zod
import { z } from '@hono/zod-openapi'
import { createRoute } from '@hono/zod-openapi'
import { OpenAPIHono } from '@hono/zod-openapi'

const ParamsSchema = z.object({
  id: z
    .string()
    .min(3)
    .openapi({
      param: {
        name: 'id',
        in: 'path',
      },
      example: '1212121',
    }),
})

const UserSchema = z
  .object({
    id: z.string().openapi({
      example: '123',
    }),
    name: z.string().openapi({
      example: 'John Doe',
    }),
    age: z.number().openapi({
      example: 42,
    }),
  })
  .openapi('User')

const route = createRoute({
  method: 'get',
  path: '/users/{id}',
  request: {
    params: ParamsSchema,
  },
  responses: {
    200: {
      content: {
        'application/json': {
          schema: UserSchema,
        },
      },
      description: 'Retrieve the user',
    },
  },
})

// entry point
const app = new OpenAPIHono()

app.openapi(route, (c) => {
  const { id } = c.req.valid('param')
  return c.json({
    id,
    age: 20,
    name: 'Ultra-man',
  })
})

// The OpenAPI documentation will be available at /doc
app.doc('/doc', {
  openapi: '3.0.0',
  info: {
    version: '1.0.0',
    title: 'My API',
  },
})

export class Task {
  // FIXME: implement
  id: string;

  constructor({ id }: { id: string }) {
    this.id = id;
  }
}

import { Result } from "@/core/result";
import { Pagination } from '@/internal/domain/model/pagination'
import { Task } from '@/internal/domain/model/task'
import { DBContext } from '@/internal/infra/database/client'
import { BaseListOptions } from './base'

export interface TasksWithPagination {
  tasks: Task[]
  pagination: Pagination
}

export class ListTaskQuery implements BaseListOptions {
  public limit: number
  public page: number
  public Preload?: boolean
  public ForUpdate?: boolean
  constructor({
    limit,
    page,
    Preload,
    ForUpdate,
  }: {
    limit: number
    page: number
    Preload?: boolean
    ForUpdate?: boolean
  }) {
    this.limit = limit
    this.page = page
    this.Preload = Preload
    this.ForUpdate = ForUpdate
  }
}

export class GetTaskQuery {
  public id: string
  public Preload?: boolean
  public ForUpdate?: boolean
  constructor({
    id,
    Preload,
    ForUpdate,
  }: {
    id: string
    Preload?: boolean
    ForUpdate?: boolean
  }) {
    this.id = id
    this.Preload = Preload
    this.ForUpdate = ForUpdate
  }
}

export interface ITaskRepository {
  create(ctx: DBContext, task: Task): Promise<Result<Task>>;
  getById(ctx: DBContext, query: GetTaskQuery): Promise<Result<Task>>;
  update(ctx: DBContext, task: Task): Promise<Result<Task>>;
  delete(ctx: DBContext, id: string): Promise<Result<Task>>;
  getAll(ctx: DBContext, query: ListTaskQuery): Promise<Result<TasksWithPagination>>;
}

import { AppError, StatusCode } from '@/core/error'
import { Result } from '@/core/result'
import { Task } from '@/internal/domain/model/task'
import {
  ITaskRepository,
  ListTaskQuery,
  GetTaskQuery,
  TasksWithPagination
} from '@/internal/domain/repository/task'
import { DBContext } from '@/internal/infra/database/client'
import { InsertTask, TaskTable } from '@/schema/db/tenant.schema'
import { count, eq } from 'drizzle-orm'

export class TaskRepository implements ITaskRepository {
  async create(ctx: DBContext, task: Task): Promise<Result<Task>> {
    const { db } = ctx
    const dbTask: InsertTask = { ...task };
    const result = await db.insert(TaskTable).values(dbTask).returning().execute();
    const res = result.at(0)
    if (!res) {
      return Result.fail(new AppError(StatusCode.INTERNAL_SERVER_ERROR, 'Failed to create Team'))
    }
    return Result.ok(new Task({ id: res.id, /* other properties */ }))
  }

  async getById(ctx: DBContext, getQuery: GetTaskQuery): Promise<Result<Task>> {
    const { db } = ctx
    const result = await db.select().from(TaskTable).where(eq(TaskTable.id, getQuery.id)).execute()
    const res = result.at(0)
    if (!res) {
      return Result.fail(new AppError(StatusCode.INTERNAL_SERVER_ERROR, 'Failed to create Team'))
    }

    return Result.ok(new Task({ id: res.id, /* other properties */ }))
  }

  async update(ctx: DBContext, task: Task): Promise<Result<Task>> {
    const { db } = ctx
    const result = await db.update(TaskTable).set({ ...task }).where(eq(TaskTable.id, task.id)).returning().execute();
    const res = result.at(0)
    if (!res) {
      return Result.fail(new AppError(StatusCode.INTERNAL_SERVER_ERROR, 'Failed to update Team'))
    }
    return Result.ok(new Task({ id: res.id, /* other properties */ }))
  }

  async delete(ctx: DBContext, id: string): Promise<Result<Task>> {
    const { db } = ctx
    const result = await db.delete(TaskTable).where(eq(TaskTable.id, id)).returning().execute();
    const res = result.at(0)
    if (!res) {
      return Result.fail(new AppError(StatusCode.INTERNAL_SERVER_ERROR, 'Failed to update Team'))
    }
    return Result.ok(new Task({ id: res.id, /* other properties */ }))
  }

  async getAll(ctx: DBContext, listQuery: ListTaskQuery): Promise<Result<TasksWithPagination>> {
    const { db } = ctx
    const query = db.select().from(TaskTable)
    if (listQuery.limit && listQuery.page > 0) {
      query.limit(listQuery.limit)
      query.offset(listQuery.limit * (listQuery.page - 1))
    }
    const result = await query.execute();
    const total = await db.select({ value: count() }).from(TaskTable).execute();
    const totalVal = total.at(0)?.value || 0;
    const ar = result.map((t) => new Task({ id: t.id, /* other properties */ }));
    return Result.ok({
      tasks: ar,
      pagination: {
        currentPage: listQuery.page,
        prevPage: listQuery.page - 1,
        nextPage: listQuery.page + 1,
        totalPage: Math.ceil(totalVal / listQuery.limit),
        totalCount: totalVal,
        hasNext: listQuery.page < Math.ceil(totalVal / listQuery.limit),
      },
    });
  }
}

import { DBClient } from '@/internal/infra/database/client';
import { TaskRepository } from '@/internal/infra/database/repository/task';
import { TransactionManager } from '@/internal/infra/database/transaction';
import { TaskInteractor } from '@/internal/usecase/task';
import { TaskHandler } from '@/internal/infra/http/server/task';

export class TaskInjector {
  private txManager: TransactionManager = new TransactionManager(DBClient.instance);
  private taskRepository = new TaskRepository();
  private taskUsecase = new TaskInteractor(this.txManager, this.taskRepository);

  get handler(): TaskHandler {
    return new TaskHandler(this.taskUsecase);
  }
}

import {
  CreateTask,
  DeleteTask,
  GetTask,
  UpdateTask,
  ListTasks,
} from '@/internal/usecase/input/task'
import { Context, TypedResponse } from 'hono'
import { ErrorResponse } from '@/schema/shared'
import {
  TaskRequestSchema,
  TaskResponseSchema,
  TaskResponse,
  TasksResponse
} from '@/schema/shared';
import {
  TaskInteractor,
} from '@/internal/usecase/task';

export type ITaskHandler = {
  create: (c: Context) => Promise<TypedResponse<TaskResponse | ErrorResponse>>,
  get: (c: Context) => Promise<TypedResponse<TaskResponse | ErrorResponse>>,
  list: (c: Context) => Promise<TypedResponse<TasksResponse | ErrorResponse>>,
  update: (c: Context) => Promise<TypedResponse<TaskResponse | ErrorResponse>>,
  delete: (c: Context) => Promise<TypedResponse<{ message: string } | ErrorResponse>>
}

export class TaskHandler implements ITaskHandler {
  private taskUsecase: TaskInteractor;

  constructor(taskUsecase: TaskInteractor) {
    this.taskUsecase = taskUsecase;
  }

  async create(c: Context): Promise<TypedResponse<TaskResponse | ErrorResponse>> {
    // Request parsing and validation
    const validationResult = TaskRequestSchema.safeParse(c.req.json());
    if (!validationResult.success) {
      const errorResponse: ErrorResponse = {
        message: JSON.stringify(validationResult.error.flatten()),
      }
      return c.json(errorResponse, 400)
    }

    // Create input for usecase
    const input: CreateTask = {
      tenantId: c.get('tenantId'),
    }
    const result = await this.taskUsecase.create(input);

    if (!result.isSuccess) {
      const errorResponse: ErrorResponse = { message: result.getError().message }
      return c.json(errorResponse, result.getError().code);
    }

    return c.json(TaskResponseSchema.parse(result.getValue()), 200);
  }

  async get(c: Context): Promise<TypedResponse<TaskResponse | ErrorResponse>> {
    // FIXME: Request parsing and validation
    const validationParamResult = TaskRequestParamSchema.safeParse(c.req.param())
    if (!validationParamResult.success) {
      const errorResponse: ErrorResponse = {
        message: JSON.stringify(validationParamResult.error.flatten()),
      }
      return c.json(errorResponse, 400)
    }

    // Create input for usecase
    const input: GetTask = {
      tenantId: c.get('tenantId'),
    };
    const result = await this.taskUsecase.get(input);

    if (!result.isSuccess) {
      const errorResponse: ErrorResponse = { message: result.getError().message }
      return c.json(errorResponse, result.getError().code);
    }

    return c.json(TaskResponseSchema.parse(result.getValue()), 200);
  }

  async list(c: Context): Promise<TypedResponse<TasksResponse | ErrorResponse>> {
    const validationParamResult = PaginationQuerySchema.safeParse(c.req.query())
    if (!validationParamResult.success) {
      const errorResponse: ErrorResponse = {
        message: JSON.stringify(validationParamResult.error.flatten()),
      }
      return c.json(errorResponse, 400)
    }
    const input: ListTasks = {
      tenantId: c.get('tenantId'),
      limit: validationParamResult.data.limit,
      page: validationParamResult.data.page,
    }
    const result = await this.taskUsecase.list(input);
    if (!result.isSuccess) {
      const errorResponse: ErrorResponse = {
        message: result.getError().message,
      }
      return c.json(errorResponse, result.getError().code)
    }

    const t = result.getValue()
    const tasksResponse: TasksResponse = {
      tasks: t.tasks.map((t) => TaskResponseSchema.parse(t)),
      pagination: {
        current_page: t.pagination.currentPage,
        total_page: t.pagination.totalPage,
        total_count: t.pagination.totalCount,
        has_next: t.pagination.hasNext,
        prev_page: t.pagination.prevPage,
        next_page: t.pagination.nextPage,
      },
    }
    return c.json(tasksResponse, 200)
  }

  async update(c: Context): Promise<TypedResponse<TaskResponse | ErrorResponse>> {
    // Request parsing and validation
    const validationResult = TaskRequestSchema.safeParse(c.req.json());
    if (!validationResult.success) {
      const errorResponse: ErrorResponse = {
        message: JSON.stringify(validationResult.error.flatten()),
      }
      return c.json(errorResponse, 400)
    }

    const validationParamResult = TaskRequestParamSchema.safeParse(c.req.param())
    if (!validationParamResult.success) {
      const errorResponse: ErrorResponse = {
        message: JSON.stringify(validationParamResult.error.flatten()),
      }
      return c.json(errorResponse, 400)
    }

    // Create input for usecase
    const input: UpdateTask = {
      tenantId: c.get('tenantId'),
    };
    const result = await this.taskUsecase.update(input);

    if (!result.isSuccess) {
      const errorResponse: ErrorResponse = { message: result.getError().message }
      return c.json(errorResponse, result.getError().code);
    }

    return c.json(TaskResponseSchema.parse(result.getValue()), 200);
  }

  async delete(c: Context): Promise<TypedResponse<{ message: string } | ErrorResponse>> {
    // FIXME: Request parsing and validation
    const validationParamResult = TaskRequestParamSchema.safeParse(c.req.param())
    if (!validationParamResult.success) {
      const errorResponse: ErrorResponse = {
        message: JSON.stringify(validationParamResult.error.flatten()),
      }
      return c.json(errorResponse, 400)
    }
    // Create input for usecase
    const input: DeleteTask = {
      tenantId: c.get('tenantId'),
      id: validationParamResult.data.team_id,
    }
    const result = await this.taskUsecase.delete(input);

    if (!result.isSuccess) {
      const errorResponse: ErrorResponse = { message: result.getError().message }
      return c.json(errorResponse, result.getError().code);
    }

    return c.json({ message: 'success' }, 200);
  }
}

export type GetTask = {
  tenantId: string
  id: string
}

export type ListTasks = {
  tenantId: string
  limit: number
  page: number
}

export type UpdateTask = {
  tenantId: string
  id: string
  // TODO: Add other fields that are required for updating a Task
}

export type DeleteTask = {
  tenantId: string
  id: string
}

export type CreateTask = {
  tenantId: string
  // TODO: Add other fields that are required for creating a new Task
}

import { Pagination } from '@/internal/domain/model/pagination'
import { Task } from '@/internal/domain/model/task'

export type ListTasks = {
  tasks: Task[]
  pagination: Pagination
}

import { Result } from '@/core/result'
import { Task } from '@/internal/domain/model/task'
import { GetTaskQuery, ITaskRepository, ListTaskQuery } from '@/internal/domain/repository/task'
import { ITransactionManager } from '@/internal/domain/repository/transaction'
import { CreateTask, GetTask, ListTasks, UpdateTask, DeleteTask } from './input'
import { ListTasks as OListTasks } from './output'

export type ITaskInteractor = {
  create(param: CreateTask): Promise<Result<Task>>
  get(param: GetTask): Promise<Result<Task>>
  list(param: ListTasks): Promise<Result<OListTasks>>
  update(param: UpdateTask): Promise<Result<Task>>
  delete(param: DeleteTask): Promise<Result<Task>>
}

export class TaskInteractor implements ITaskInteractor {
  private transactionManager: ITransactionManager
  private taskRepository: ITaskRepository

  constructor(transactionManager: ITransactionManager, taskRepository: ITaskRepository) {
    this.transactionManager = transactionManager
    this.taskRepository = taskRepository
  }

  async create(input: CreateTask): Promise<Result<Task>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      // TODO: Add logic to create a new Task
      const repoResult = await this.taskRepository.create(ctx, new Task(...));
      return repoResult
    })
  }

  async get(input: GetTask): Promise<Result<Task>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      const getQuery = new GetTaskQuery({
        id: input.id,
      })
      const repoResult = await this.taskRepository.getById(ctx, getQuery)
      return repoResult
    })
  }

  async list(input: ListTasks): Promise<Result<OListTasks>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      // TODO: Add logic to list Tasks
      const listQuery = new ListTaskQuery({
        userId: input.userId,
        limit: input.limit,
        page: input.page,
      })
      const repoResult = await this.taskRepository.getAll(ctx, listQuery);
      return Result.ok({ tasks: repoResult.getValue().tasks, pagination: repoResult.getValue().pagination });
    })
  }

  async update(input: UpdateTask): Promise<Result<Task>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      const getQuery = new GetTaskQuery({
        id: input.id,
      })
      const getRepoResult = await this.taskRepository.getById(ctx, getQuery)
      if (!getRepoResult.isSuccess) {
        return Result.fail(getRepoResult.getError())
      }
      const updatedTask = getRepoResult.getValue()
      // TODO: Update the Task as needed
      const repoResult = await this.taskRepository.update(ctx, updatedTask)
      return repoResult
    })
  }

  async delete(input: DeleteTask): Promise<Result<Task>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      const repoResult = await this.taskRepository.delete(ctx, input.id)
      return repoResult
    })
  }
}

---
to: internal/usecase/<%= h.inflection.underscore(entity.toLowerCase()) %>.ts
---
import { Result } from '@/core/result'
import { <%= h.inflection.classify(entity) %> } from '@/internal/domain/model/<%= h.inflection.underscore(entity.toLowerCase()) %>'
import { Get<%= h.inflection.classify(entity) %>Query, I<%= h.inflection.classify(entity) %>Repository, List<%= h.inflection.classify(entity) %>Query } from '@/internal/domain/repository/<%= h.inflection.underscore(entity.toLowerCase()) %>'
import { ITransactionManager } from '@/internal/domain/repository/transaction'
import { Create<%= h.inflection.classify(entity) %>, Get<%= h.inflection.classify(entity) %>, List<%= h.inflection.classify(entity) %>s, Update<%= h.inflection.classify(entity) %>, Delete<%= h.inflection.classify(entity) %> } from './input'
import { List<%= h.inflection.classify(entity) %>s as OList<%= h.inflection.classify(entity) %>s } from './output'

export type I<%= h.inflection.classify(entity) %>Interactor = {
  create(param: Create<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>>
  get(param: Get<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>>
  list(param: List<%= h.inflection.classify(entity) %>s): Promise<Result<OList<%= h.inflection.classify(entity) %>s>>
  update(param: Update<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>>
  delete(param: Delete<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>>
}

export class <%= h.inflection.classify(entity) %>Interactor implements I<%= h.inflection.classify(entity) %>Interactor {
  private transactionManager: ITransactionManager
  private <%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository: I<%= h.inflection.classify(entity) %>Repository

  constructor(transactionManager: ITransactionManager, <%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository: I<%= h.inflection.classify(entity) %>Repository) {
    this.transactionManager = transactionManager
    this.<%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository = <%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository
  }

  async create(input: Create<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      // TODO: Add logic to create a new <%= h.inflection.classify(entity) %>
      const repoResult = await this.<%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository.create(ctx, new <%= h.inflection.classify(entity) %>(...));
      return repoResult
    })
  }

  async get(input: Get<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      const getQuery = new Get<%= h.inflection.classify(entity) %>Query({
        id: input.id,
      })
      const repoResult = await this.<%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository.getById(ctx, getQuery)
      return repoResult
    })
  }

  async list(input: List<%= h.inflection.classify(entity) %>s): Promise<Result<OList<%= h.inflection.classify(entity) %>s>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      // TODO: Add logic to list <%= h.inflection.pluralize(entity) %>
      const listQuery = new List<%= h.inflection.classify(entity) %>Query({
        userId: input.userId,
        limit: input.limit,
        page: input.page,
      })
      const repoResult = await this.<%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository.getAll(ctx, listQuery);
      return Result.ok({ <%= h.inflection.pluralize(entity.toLowerCase()) %>: repoResult.getValue().<%= h.inflection.pluralize(entity.toLowerCase()) %>, pagination: repoResult.getValue().pagination });
    })
  }

  async update(input: Update<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      const getQuery = new Get<%= h.inflection.classify(entity) %>Query({
        id: input.id,
      })
      const getRepoResult = await this.<%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository.getById(ctx, getQuery)
      if (!getRepoResult.isSuccess) {
        return Result.fail(getRepoResult.getError())
      }
      const updated<%= h.inflection.classify(entity) %> = getRepoResult.getValue()
      // TODO: Update the <%= h.inflection.classify(entity) %> as needed
      const repoResult = await this.<%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository.update(ctx, updated<%= h.inflection.classify(entity) %>)
      return repoResult
    })
  }

  async delete(input: Delete<%= h.inflection.classify(entity) %>): Promise<Result<<%= h.inflection.classify(entity) %>>> {
    return this.transactionManager.withTransaction(input.tenantId, async (ctx) => {
      const repoResult = await this.<%= h.inflection.camelize(entity.toLowerCase(), true) %>Repository.delete(ctx, input.id)
      return repoResult
    })
  }
}