@3lineas/grooveskills 1.7.2 → 1.8.0

package/skills/controller-orchestration-queues/references/controller-queue-examples.md

@@ -1,13 +1,51 @@
-# Implementation Reference: Controller Orchestration & Queue Adapters
+# Implementation Reference: Controller Orchestration, Queues & D1 Transactions
 
-Real-world queue adapters (Cloudflare Queues, BullMQ, AWS SQS, In-Memory) and Slim Worker controllers.
+Real-world queue adapters (Cloudflare Queues, BullMQ, AWS SQS, In-Memory) and atomic Cloudflare D1 transaction runner.
 
 ---
 
-## 1. Cloudflare Queues Adapter
+## 1. Cloudflare D1 Atomic Transaction Runner (`withD1Transaction`)
+
+Cloudflare D1 runs SQLite at the edge, where standard multi-statement transactions are executed via `db.batch()`. The `withD1Transaction` pattern allows actions to stage statements and execute them atomically:
+
+```ts
+import type { DrizzleD1Database } from "drizzle-orm/d1";
+import type { BatchItem } from "drizzle-orm/batch";
+
+export interface D1TransactionContext<TSchema extends Record<string, unknown>> {
+  readonly db: DrizzleD1Database<TSchema>;
+  stage: (statement: BatchItem<"sqlite">) => void;
+}
+
+export async function withD1Transaction<TSchema extends Record<string, unknown>, TResult>(
+  database: DrizzleD1Database<TSchema>,
+  callback: (transaction: D1TransactionContext<TSchema>) => Promise<TResult>
+): Promise<TResult> {
+  const stagedStatements: BatchItem<"sqlite">[] = [];
+
+  const transactionContext: D1TransactionContext<TSchema> = {
+    db: database,
+    stage: (statement) => {
+      stagedStatements.push(statement);
+    },
+  };
+
+  const result = await callback(transactionContext);
+
+  if (stagedStatements.length > 0) {
+    // All staged mutations are executed in a single atomic batch
+    await database.batch(stagedStatements as [BatchItem<"sqlite">, ...BatchItem<"sqlite">[]]);
+  }
+
+  return result;
+}
+```
+
+---
+
+## 2. Cloudflare Queues Adapter
 
 ```ts
-// src/infrastructure/adapters/queue/cloudflare-queues.adapter.ts
 import type { QueuePort, QueueJob } from "@/domains/queue/queue.port";
 import { AppError } from "@/errors/app-error";
 
@@ -18,13 +56,17 @@ export class CloudflareQueueAdapter implements QueuePort {
     try {
       await this.queue.send(job, { delaySeconds: job.delaySeconds });
       return { jobId: job.id ?? crypto.randomUUID() };
-    } catch (err) {
-      throw new AppError({ message: "Error al encolar mensaje en Cloudflare Queues.", statusCode: 502, cause: err });
+    } catch (caughtError) {
+      throw new AppError({
+        message: "Error al encolar mensaje en Cloudflare Queues.",
+        statusCode: 502,
+        cause: caughtError,
+      });
     }
   }
 
   async dispatchBatch<T>(jobs: QueueJob<T>[]): Promise<{ count: number }> {
-    await this.queue.sendBatch(jobs.map((j) => ({ body: j, delaySeconds: j.delaySeconds })));
+    await this.queue.sendBatch(jobs.map((job) => ({ body: job, delaySeconds: job.delaySeconds })));
     return { count: jobs.length };
   }
 }
@@ -32,10 +74,9 @@ export class CloudflareQueueAdapter implements QueuePort {
 
 ---
 
-## 2. BullMQ (Redis) Adapter
+## 3. BullMQ (Redis) Adapter
 
 ```ts
-// src/infrastructure/adapters/queue/bullmq-queues.adapter.ts
 import { Queue as BullQueue } from "bullmq";
 import type { QueuePort, QueueJob } from "@/domains/queue/queue.port";
 import { AppError } from "@/errors/app-error";
@@ -45,22 +86,26 @@ export class BullMQAdapter implements QueuePort {
 
   async dispatch<T>(job: QueueJob<T>): Promise<{ jobId: string }> {
     try {
-      const bJob = await this.bullQueue.add(job.name, job.data, {
+      const queuedJob = await this.bullQueue.add(job.name, job.data, {
         jobId: job.id,
         delay: job.delaySeconds ? job.delaySeconds * 1000 : undefined,
       });
-      return { jobId: String(bJob.id) };
-    } catch (err) {
-      throw new AppError({ message: "Error al enviar trabajo a BullMQ.", statusCode: 502, cause: err });
+      return { jobId: String(queuedJob.id) };
+    } catch (caughtError) {
+      throw new AppError({
+        message: "Error al enviar trabajo a BullMQ.",
+        statusCode: 502,
+        cause: caughtError,
+      });
     }
   }
 
   async dispatchBatch<T>(jobs: QueueJob<T>[]): Promise<{ count: number }> {
     await this.bullQueue.addBulk(
-      jobs.map((j) => ({
-        name: j.name,
-        data: j.data,
-        opts: { jobId: j.id, delay: j.delaySeconds ? j.delaySeconds * 1000 : undefined },
+      jobs.map((job) => ({
+        name: job.name,
+        data: job.data,
+        opts: { jobId: job.id, delay: job.delaySeconds ? job.delaySeconds * 1000 : undefined },
       }))
     );
     return { count: jobs.length };
@@ -70,19 +115,18 @@ export class BullMQAdapter implements QueuePort {
 
 ---
 
-## 3. In-Memory Queue Adapter (Testing Fake)
+## 4. In-Memory Queue Adapter (Testing Fake)
 
 ```ts
-// src/infrastructure/adapters/queue/memory-queues.adapter.ts
 import type { QueuePort, QueueJob } from "@/domains/queue/queue.port";
 
 export class MemoryQueueAdapter implements QueuePort {
   public jobs: QueueJob[] = [];
 
   async dispatch<T>(job: QueueJob<T>): Promise<{ jobId: string }> {
-    const id = job.id ?? `job_${this.jobs.length + 1}`;
-    this.jobs.push({ ...job, id });
-    return { jobId: id };
+    const jobId = job.id ?? `job_${this.jobs.length + 1}`;
+    this.jobs.push({ ...job, id: jobId });
+    return { jobId };
   }
 
   async dispatchBatch<T>(jobs: QueueJob<T>[]): Promise<{ count: number }> {
@@ -93,23 +137,3 @@ export class MemoryQueueAdapter implements QueuePort {
   }
 }
 ```
-
----
-
-## 4. Slim Queue Worker Controller Pattern
-
-```ts
-// src/infrastructure/workers/order-events.worker.ts
-import { sendOrderEmailAction } from "@/actions/email/send-order-email.action";
-import { syncCrmAction } from "@/actions/crm/sync-crm.action";
-import { logger } from "@/infrastructure/logger/app-logger";
-
-export async function handleOrderQueueMessage(messageBody: { name: string; data: { orderId: string; customerEmail: string } }) {
-  logger.info("Procesando evento de orden", { jobName: messageBody.name, orderId: messageBody.data.orderId });
-
-  if (messageBody.name === "orders.post-checkout") {
-    await sendOrderEmailAction(messageBody.data.customerEmail, messageBody.data.orderId);
-    await syncCrmAction(messageBody.data.orderId);
-  }
-}
-```

package/skills/error-handling-logging/SKILL.md

@@ -1,99 +1,95 @@
 ---
 name: error-handling-logging
-description: Deterministic error handling with custom AppError, Result/ActionResponse contracts, and structured logging. TRIGGER when designing error boundaries, writing try/catch blocks, handling I/O or network failures, creating domain exceptions, or configuring application loggers.
+description: Deterministic error handling with custom AppError, domain exception hierarchies, silent mode, Result/ActionResponse contracts, and structured logging. TRIGGER when designing error boundaries, writing try/catch blocks, handling I/O or network failures, creating domain exceptions, or configuring application loggers.
 ---
 
 # Error Handling & Structured Logging Standards
 
-Enterprise-grade patterns for deterministic error handling, structured context logging, and safe API error responses.
+Enterprise-grade patterns for deterministic error handling, typed domain exceptions, silent log mode for expected business flows, and safe API error responses.
 
 ---
 
 ## 1. Golden Rules (Non-negotiable)
 
-1. **Typed Domain Errors with `AppError`**:
-   - Never throw raw strings or generic untyped `Error("something failed")`.
-   - Throw structured `AppError` instances with HTTP status code, error code identifier, user-safe message, and optional contextual metadata.
+1. **Hierarchy Based on `AppError`**:
+   - Every domain error or business exception **MUST** extend `AppError`.
+   - Never throw raw strings or generic untyped `Error("failed")` in domain actions or controllers.
 
-2. **Never Swallow Errors Silently**:
-   - Every `catch (err)` block must either:
-     - Recover with an explicit fallback value.
-     - Log with `Logger.error(...)` and re-throw / return an `ActionResponse` failure.
-   - Empty catch blocks (`catch {}`) without explicit intent are forbidden.
+2. **Atomic Domain Exceptions (1 Exception per File)**:
+   - Each custom exception resides in its own atomic file: `@/errors/{domain}/{name}.error.ts` (e.g. `slug-conflict.error.ts`, `user-not-found.error.ts`).
+   - Throw custom errors directly without boilerplate try/catch re-wrapping inside business logic.
 
-3. **Separate User-Safe Messages from Internal Diagnostics**:
-   - The user receives polite, actionable feedback (e.g. *"Unable to complete transaction. Please try again."*).
-   - Internal logs receive complete diagnostic metadata (stack trace, payload params, correlation ID, elapsed time).
+3. **Auto-Logging with `silent: true` for Expected Flows**:
+   - `AppError` emits a warning via structured logger upon instantiation.
+   - For expected user conflicts (e.g. 409 duplicate slug, 404 not found, 400 validation error), set `silent: true` in the constructor to avoid polluting server error alerts.
 
-4. **Result / ActionResponse for Non-fatal Domain Failures**:
-   - Prefer returning `{ success: false, error: "..." }` or `Result<T, E>` across service boundaries when the failure is an expected domain outcome (e.g. validation failure, duplicate email).
+4. **Universal Error Normalization in Catch Blocks**:
+   - Every top-level catch block or global error handler must normalize unknown or unexpected runtime errors into `AppError` subclasses (e.g. `InternalServerError`).
+   - All HTTP responses are formatted via standardized response serialization (`ActionResponse<never>`).
 
-5. **Structured JSON-Ready Logging**:
-   - Avoid `console.log("here 1")` in production code.
-   - Use a structured `Logger` utility emitting timestamp, level (`DEBUG`, `INFO`, `WARN`, `ERROR`), message, and contextual metadata object.
+5. **Separate User-Safe Messages from Internal Diagnostics**:
+   - The user receives courteous, empathetic, and actionable feedback in the configured locale (governed by `ux-writing`).
+   - Internal logs receive complete diagnostic metadata (stack trace, payload params, correlation ID).
 
----
-
-## 2. Standard Contracts
-
-### A. The ActionResponse Contract
-
-```ts
-export type ActionResponse<TData = unknown, TError = string> =
-  | { success: true; data: TData; message?: string }
-  | { success: false; error: TError; message?: string; statusCode?: number };
+6. **Hard Size Limit of <200 Lines**:
+   - Keep atomic exception classes under 40 lines and error handlers concise.
 
-export function successResponse<T>(data: T, message?: string): ActionResponse<T> {
-  return { success: true, data, message };
-}
+---
 
-export function errorResponse(error: string, statusCode = 400): ActionResponse<never> {
-  return { success: false, error, statusCode };
-}
+## 2. Directory Layout
+
+```text
+src/
+├── errors/
+│   ├── app-error.ts                  # Base AppError with auto-logging & silent flag
+│   ├── common/
+│   │   ├── internal-server.error.ts  # 500 error for unhandled exceptions
+│   │   └── validation.error.ts       # 400 error for schema validation
+│   └── {domain}/                     # Domain-specific custom exceptions
+│       ├── slug-conflict.error.ts    # e.g., extends AppError (409, silent: true)
+│       └── entity-not-found.error.ts # e.g., extends AppError (404, silent: true)
+└── types/errors/
+    └── app-error-params.type.ts      # AppError constructor options
 ```
 
-### B. The `AppError` Base Class
+---
 
-See `templates/app-error.template.md` for full implementation.
+## 3. Standard Contracts & Domain Exceptions
 
+### A. Domain Custom Exception Example (`src/errors/stores/slug-conflict.error.ts`)
 ```ts
-export class AppError extends Error {
-  readonly statusCode: number;
-  readonly code: string;
-  readonly details?: unknown;
-
-  constructor(opts: { message: string; statusCode?: number; code?: string; details?: unknown }) {
-    super(opts.message);
-    this.name = "AppError";
-    this.statusCode = opts.statusCode ?? 500;
-    this.code = opts.code ?? "INTERNAL_SERVER_ERROR";
-    this.details = opts.details;
+import { AppError } from "@/errors/app-error";
+
+export class SlugConflictError extends AppError {
+  constructor(
+    slug: string,
+    message = `El enlace '${slug}' ya está registrado. Te sugerimos agregar una palabra o número adicional.`
+  ) {
+    super({
+      message,
+      statusCode: 409,
+      code: "SLUG_ALREADY_IN_USE",
+      details: { slug },
+      silent: true, // Expected business conflict: suppress error log alert
+    });
+    this.name = "SlugConflictError";
   }
 }
 ```
 
----
-
-## 3. Safe Try/Catch Pattern
-
+### B. Universal Catch Normalization Pattern
 ```ts
-import { Logger } from "@/utils/logger";
 import { AppError } from "@/errors/app-error";
-import { type ActionResponse, errorResponse, successResponse } from "@/types/response.types";
-
-export async function executeSafeTask<T>(task: () => Promise<T>): Promise<ActionResponse<T>> {
-  try {
-    const result = await task();
-    return successResponse(result);
-  } catch (error: unknown) {
-    if (error instanceof AppError) {
-      Logger.warn("Expected domain error caught", { code: error.code, message: error.message });
-      return errorResponse(error.message, error.statusCode);
-    }
-
-    Logger.error("Unhandled runtime exception in task execution", { error });
-    return errorResponse("An unexpected error occurred. Please try again later.", 500);
+import { InternalServerError } from "@/errors/common/internal-server.error";
+
+export function normalizeError(caughtError: unknown): AppError {
+  if (caughtError instanceof AppError) {
+    return caughtError;
   }
+  return new InternalServerError({
+    message: "Ocurrió un error inesperado al procesar la solicitud.",
+    cause: caughtError,
+  });
 }
 ```
 
@@ -101,5 +97,5 @@ export async function executeSafeTask<T>(task: () => Promise<T>): Promise<Action
 
 ## 4. Templates
 
-- `templates/app-error.template.md`: Complete extensible `AppError` implementation with serialization.
-- `templates/logger.template.md`: Lightweight structured logger with log levels and JSON output formatting.
+- `./templates/app-error.template.md`: Complete extensible `AppError` base class with `silent` mode.
+- `./templates/logger.template.md`: Lightweight structured logger with contextual metadata.

package/skills/error-handling-logging/templates/app-error.template.md

@@ -1,14 +1,18 @@
-# Template: AppError Class
+# Template: AppError Base Class
 
 Copy or adapt this template when setting up error handling in your project: `src/errors/app-error.ts`.
 
 ```ts
+import { Logger } from "@/utils/logger";
+
 export interface AppErrorOptions {
   message: string;
   statusCode?: number;
   code?: string;
   details?: unknown;
   cause?: unknown;
+  /** When true, suppresses automatic warning logging for expected business conflicts */
+  silent?: boolean;
 }
 
 export class AppError extends Error {
@@ -28,6 +32,11 @@ export class AppError extends Error {
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, AppError);
     }
+
+    if (!options.silent) {
+      const logger = new Logger(`API:Error:${this.name}`);
+      logger.warn(`${this.code}: ${this.message}`, { details: this.details });
+    }
   }
 
   toJSON(): Record<string, unknown> {

package/skills/hono/SKILL.md

@@ -3,96 +3,103 @@ name: hono
 description: Use when building or modifying Hono APIs, endpoints, middlewares, or actions. TRIGGER when the project imports 'hono', when modifying routes in src/modules/ or actions in src/actions/, or when the user mentions Hono, API endpoints, or routing. Always validate with Valibot (* as v from 'valibot') and adhere to the 'best-practices' skill.
 ---
 
-# Hono Architecture & Opinionated Best Practices
+# Hono Architecture & Thin Route Standards
 
-Standardized guide for building robust, scalable, enterprise-grade Hono applications with isolated domain layers, strict Valibot validation, and typed Actions.
+Standardized guide for building robust, scalable Hono applications with isolated domain layers, strict Valibot validation, typed Actions, and thin route wrappers.
 
 ---
 
 ## 1. Golden Rules (Non-negotiable)
 
 1. **Standard Schema Validator with Valibot**:
-   - Always use **Valibot** (`* as v from "valibot"`) with `@hono/standard-validator` (`sValidator`) or `@hono/valibot-validator`.
-   - Never use Zod.
-2. **Mandatory Path Aliases (`@/...`)**:
-   - Import all internal modules using configured path aliases (`@/actions/...`, `@/schemas/...`, `@/errors/...`).
-3. **Zero Barrel Files**:
-   - Never create `index.ts` files that re-export multiple routes or actions.
-   - Import directly from each specific action and schema file.
+   - Always use **Valibot** (`* as v from "valibot"`) with `@hono/valibot-validator` (`vValidator`) or `@hono/standard-validator` (`sValidator`).
+   - Use `validationHook` to intercept schema issues and emit a standardized `400 Bad Request` with `ActionResponse<never>`.
+
+2. **Strict Route Wrapper (`createRouteHandler`)**:
+   - Endpoints must be thin controllers. Wrap routes with `createRouteHandler({ outputSchema, status }, handler)`.
+   - Handler automatically receives `{ db, logger, env, input, ctx }`, handles try/catch normalization to `AppError`, and returns serialized `ActionResponse<T>`.
+
+3. **Strict Identifier Naming**:
+   - The Hono context parameter is **ALWAYS** named `ctx` (NEVER `c`).
+   - Catch errors are **ALWAYS** named `error` or `caughtError` (NEVER `e` or `err`).
+
 4. **Independent Route per File by Domain**:
-   - Every single endpoint resides in its own file (`src/modules/{domain}/{action}.ts`).
-   - Group them under the domain router `src/modules/{domain}/{domain}.router.ts`.
-5. **Business Logic Exclusively in Actions**:
-   - All business logic lives inside `src/actions/{domain}/{action}.action.ts`.
-   - Routers are slim controllers: validate input, call the action, return the response.
-6. **Database Connections strictly in Actions**:
-   - Never execute SQL, D1, Drizzle, or Prisma queries inside routes or middleware.
-   - The database instance is injected from Hono context (`ctx.get("db")`) into the action function.
-7. **Single Responsibility Principle (SRP)**:
-   - Each action performs **exactly one** business action.
-8. **Hard File Limit**:
-   - Maximum **200 lines per file**.
-9. **Unified Error Handling**:
-   - Throw typed `AppError` instances for business failures.
-   - Wrap I/O operations in `try / catch`, log with structured `Logger`, and re-throw or propagate to `globalErrorHandler`.
-10. **Courteous and Professional User Feedback**:
-    - Return polite, engaging, and solution-oriented messages in English (`ActionResponse<T>`).
+   - Every single endpoint resides in its own file (`src/routes/modules/{domain}/{action}.route.ts`).
+   - Group them under the domain router `src/routes/modules/{domain}/{domain}.router.ts` and mount in root router.
+
+5. **Business Logic Exclusively in Actions / Pipelines**:
+   - All business logic lives in `src/actions/{domain}/{action}.action.ts`.
+   - Never execute SQL, D1, Drizzle, or Prisma queries directly inside route handlers.
+
+6. **Hard Size Limit: <200 Lines Max**:
+   - Keep route endpoints under 60 lines and routers under 50 lines.
+
+7. **Unified Client Response (`ActionResponse<T>`)**:
+   - Every API endpoint response (success or failure) conforms to `ActionResponse<T>` (`success`, `message`, `data`, `error`).
 
 ---
 
 ## 2. Directory Taxonomy
 
 ```text
-apps/api/src/
-├── actions/                         # Pure business logic layer
-│   └── auth/
-│       ├── register-user.action.ts  # One atomic action (< 100 lines)
-│       └── login-user.action.ts
-├── modules/                         # Thin HTTP controllers
-│   └── auth/
-│       ├── register-user.ts         # Endpoint definition (< 80 lines)
-│       └── auth.router.ts           # Domain router mounting endpoints (< 60 lines)
-├── schemas/                         # Valibot schemas
-│   └── auth/
-│       └── register-user.schema.ts  # Strict input schema (< 50 lines)
-├── errors/
-│   ├── app-error.ts                 # Base application error with auto-logging
-│   └── error-handler.ts             # Central Hono error handler
-└── routers/
-    └── api.router.ts                # Root router exporting ApiRouter type for RPC
+src/
+├── routes/
+│   ├── index.ts                     # Main apiRouter mounting domain routers
+│   └── modules/{domain}/
+│       ├── {action}.route.ts        # Atomic endpoint (<60 lines)
+│       └── {domain}.router.ts       # Domain assembly router (<50 lines)
+├── dtos/{domain}/                   # Valibot schemas (<50 lines)
+├── actions/{domain}/                # Atomic business logic (<100 lines)
+└── types/                           # Isolated domain contracts (<50 lines)
 ```
 
 ---
 
-## 3. Valibot Validation Example
+## 3. Thin Route Pattern Example
 
 ```ts
-import { sValidator } from "@hono/standard-validator";
-import * as v from "valibot";
-
-export const loginSchema = v.object({
-  email: v.pipe(
-    v.string("Please provide your email address."),
-    v.email("Please provide a valid email address.")
-  ),
-  password: v.pipe(
-    v.string("Password is required."),
-    v.minLength(8, "Your password must be at least 8 characters long.")
-  ),
-});
-
-export type LoginInput = v.InferOutput<typeof loginSchema>;
+import { Hono } from "hono";
+import { vValidator } from "@hono/valibot-validator";
+import type { AppContext } from "@/types/context/app-context.type";
+import type { CreateUserInput } from "@/types/users/create-user-input.type";
+import { CreateUserDto } from "@/dtos/users/create-user.dto";
+import { UserResponseDto } from "@/dtos/users/user-response.dto";
+import { registerUserAction } from "@/actions/users/register-user.action";
+import { createRouteHandler } from "@/common/utils/route-handler";
+import { validationHook } from "@/common/utils/validation";
+
+export const createUserRoute = new Hono<AppContext>().post(
+  "/",
+  vValidator("json", CreateUserDto, validationHook),
+  createRouteHandler<unknown, typeof UserResponseDto, CreateUserInput>(
+    { outputSchema: UserResponseDto, status: 201 },
+    async ({ db, input }) => {
+      return await registerUserAction(db, input!);
+    }
+  )
+);
 ```
 
 ---
 
-## 4. Standard Response Contract
+## 4. Domain Router Assembly
 
 ```ts
-export interface ActionResponse<T = unknown> {
-  success: boolean;
-  message?: string;
-  error?: string;
-  data?: T;
-}
+import { Hono } from "hono";
+import type { AppContext } from "@/types/context/app-context.type";
+import { createUserRoute } from "./create-user.route";
+import { listUsersRoute } from "./list-users.route";
+
+export const usersRouter = new Hono<AppContext>()
+  .route("/", createUserRoute)
+  .route("/", listUsersRoute);
 ```
+
+---
+
+## 5. Templates
+
+- `./templates/router.template.md`: Atomic route template with `createRouteHandler`.
+- `./templates/action.template.md`: Single responsibility Action template.
+- `./templates/schema.template.md`: Valibot schema template with UX microcopy.
+- `./templates/error-handler.template.md`: Centralized error handler template.

package/skills/hono/templates/router.template.md

@@ -1,35 +1,27 @@
 # Hono Route Template
 
-Slim HTTP controller that validates request body with Valibot and delegates directly to the Action.
+Slim HTTP controller that validates request body with Valibot via `validationHook`, uses `createRouteHandler`, and delegates to the Action.
 
 ```ts
 import { Hono } from "hono";
-import { sValidator } from "@hono/standard-validator";
-import { registerUserSchema } from "@/schemas/auth/register-user.schema.ts";
-import { registerUserAction } from "@/actions/auth/register-user.action.ts";
-import type { DatabaseConnection } from "@/actions/auth/register-user.action.ts";
+import { vValidator } from "@hono/valibot-validator";
+import type { AppContext } from "@/types/context/app-context.type";
+import type { RegisterUserInput } from "@/types/auth/register-user-input.type";
+import { RegisterUserDto } from "@/dtos/auth/register-user.dto";
+import { UserResponseDto } from "@/dtos/auth/user-response.dto";
+import { registerUserAction } from "@/actions/auth/register-user.action";
+import { createRouteHandler } from "@/common/utils/route-handler";
+import { validationHook } from "@/common/utils/validation";
 
-export interface CustomVariables {
-  db: DatabaseConnection;
-}
-
-export const registerUserRoute = new Hono<{ Variables: CustomVariables }>().post(
+export const registerUserRoute = new Hono<AppContext>().post(
   "/",
-  sValidator("json", registerUserSchema),
-  async (ctx) => {
-    const input = ctx.req.valid("json");
-    const db = ctx.get("db");
-
-    const createdUser = await registerUserAction(db, input);
-
-    return ctx.json(
-      {
-        success: true,
-        message: "Welcome aboard! Your account has been created successfully.",
-        data: createdUser,
-      },
-      201
-    );
-  }
+  vValidator("json", RegisterUserDto, validationHook),
+  createRouteHandler<unknown, typeof UserResponseDto, RegisterUserInput>(
+    { outputSchema: UserResponseDto, status: 201 },
+    async ({ db, input }) => {
+      const createdUser = await registerUserAction(db, input!);
+      return createdUser;
+    }
+  )
 );
 ```