create-nexwire 4.0.0

package/hono/src/framework/maker-cli/stubs/example/route.api.ts.stub

@@ -0,0 +1,207 @@
+import { createRoute, createRouter, HttpStatusCodes, jsonContent, z } from "@/framework/facade.js";
+import { env } from "@/env.js";
+import { downloadGenerated, downloadGeneratedExcel, downloadGeneratedPdf, fire, fireBroadcast, fireQueued, fireQueuedBroadcast, generateDownload, generateExcelDownload, generatePdfDownload, importExcel, queueCommand, upload } from "@/modules/{{module}}/controllers/{{module}}.controller.js";
+import { DownloadTokenSchema, ExcelDownloadRequestSchema, ExampleEventSchema, PdfGenerateAcceptedSchema, PdfGenerateRequestSchema, QueueCommandRequestSchema, UploadResponseSchema } from "@/modules/{{module}}/controllers/{{module}}.schema.js";
+
+const eventRoute = createRoute({
+  path: "/event",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: jsonContent(ExampleEventSchema, "Examples event payload")
+  },
+  responses: {
+    [HttpStatusCodes.ACCEPTED]: jsonContent(z.object({ message: z.string(), data: ExampleEventSchema }), "Event accepted")
+  }
+});
+
+const queueCommandRoute = createRoute({
+  path: "/queue/command",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: jsonContent(QueueCommandRequestSchema, "Queue command payload")
+  },
+  responses: {
+    [HttpStatusCodes.ACCEPTED]: jsonContent(z.object({ message: z.string(), data: QueueCommandRequestSchema }), "Queue command dispatched")
+  }
+});
+
+const queuedEventRoute = createRoute({
+  path: "/event/queued",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: jsonContent(ExampleEventSchema, "Queued event payload")
+  },
+  responses: {
+    [HttpStatusCodes.ACCEPTED]: jsonContent(z.object({ message: z.string(), data: ExampleEventSchema }), "Queued event accepted")
+  }
+});
+
+const queuedBroadcastEventRoute = createRoute({
+  path: "/event/queued-broadcast",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: jsonContent(ExampleEventSchema, "Queued broadcast event payload")
+  },
+  responses: {
+    [HttpStatusCodes.ACCEPTED]: jsonContent(z.object({ message: z.string(), data: ExampleEventSchema }), "Queued broadcast event accepted")
+  }
+});
+
+const broadcastRoute = createRoute({
+  path: "/event/broadcast",
+  method: "post",
+  tags: ["Examples"],
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent(z.object({
+      message: z.string(),
+      data: z.object({ message: z.string(), firedAt: z.string() })
+    }), "Broadcast event dispatched")
+  }
+});
+
+const uploadRoute = createRoute({
+  path: "/upload",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: {
+      content: {
+        "multipart/form-data": {
+          schema: z.object({ file: z.any().openapi({ type: "string", format: "binary" }) })
+        }
+      }
+    }
+  },
+  responses: {
+    [HttpStatusCodes.OK]: {
+      description: "File uploaded",
+      content: { "application/json": { schema: UploadResponseSchema } }
+    }
+  }
+});
+
+const importExcelRoute = createRoute({
+  path: "/import/excel",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: {
+      content: {
+        "multipart/form-data": {
+          schema: z.object({ file: z.any().openapi({ type: "string", format: "binary" }) })
+        }
+      }
+    }
+  },
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent(z.object({
+      message: z.string(),
+      data: z.object({
+        sheetName: z.string(),
+        headers: z.array(z.string()),
+        totalRows: z.number(),
+        preview: z.array(z.record(z.string(), z.union([z.string(), z.number(), z.null()])))
+      })
+    }), "Excel import preview")
+  }
+});
+
+const generateDownloadRoute = createRoute({
+  path: "/download/generate",
+  method: "post",
+  tags: ["Examples"],
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent(DownloadTokenSchema, "Temporary download token")
+  }
+});
+
+const downloadRoute = createRoute({
+  path: "/download/{token}",
+  method: "get",
+  tags: ["Examples"],
+  request: {
+    params: z.object({ token: z.string() })
+  },
+  responses: {
+    [HttpStatusCodes.OK]: { description: "Downloads generated file and deletes it" },
+    [HttpStatusCodes.NOT_FOUND]: jsonContent(z.object({ message: z.string() }), "Invalid token")
+  }
+});
+
+const generateExcelRoute = createRoute({
+  path: "/download/excel/generate",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: jsonContent(ExcelDownloadRequestSchema, "Excel generation payload")
+  },
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent(DownloadTokenSchema, "Excel temporary download token")
+  }
+});
+
+const downloadExcelRoute = createRoute({
+  path: "/download/excel/{token}",
+  method: "get",
+  tags: ["Examples"],
+  request: {
+    params: z.object({ token: z.string() })
+  },
+  responses: {
+    [HttpStatusCodes.OK]: { description: "Downloads generated Excel file and deletes it" },
+    [HttpStatusCodes.NOT_FOUND]: jsonContent(z.object({ message: z.string() }), "Invalid token")
+  }
+});
+
+const generatePdfRoute = createRoute({
+  path: "/download/pdf/generate",
+  method: "post",
+  tags: ["Examples"],
+  request: {
+    body: jsonContent(PdfGenerateRequestSchema, "Hybrid PDF generation payload")
+  },
+  responses: {
+    [HttpStatusCodes.ACCEPTED]: jsonContent(PdfGenerateAcceptedSchema, "Queued or inline PDF response")
+  }
+});
+
+const downloadPdfRoute = createRoute({
+  path: "/download/pdf/{requestId}",
+  method: "get",
+  tags: ["Examples"],
+  request: {
+    params: z.object({ requestId: z.string() })
+  },
+  responses: {
+    [HttpStatusCodes.OK]: { description: "Downloads generated PDF" },
+    [HttpStatusCodes.ACCEPTED]: jsonContent(z.object({ message: z.string(), state: z.string() }), "Still generating"),
+    [HttpStatusCodes.NOT_FOUND]: jsonContent(z.object({ message: z.string() }), "Unknown request")
+  }
+});
+
+const enabled = env.ENABLE_EXAMPLES;
+const router = createRouter();
+
+if (enabled) {
+  router
+    .api(eventRoute, fire)
+    .api(queueCommandRoute, queueCommand)
+    .api(queuedEventRoute, fireQueued)
+    .api(queuedBroadcastEventRoute, fireQueuedBroadcast)
+    .api(broadcastRoute, fireBroadcast)
+    .api(uploadRoute, upload)
+    .api(importExcelRoute, importExcel)
+    .api(generateDownloadRoute, generateDownload)
+    .api(downloadRoute, downloadGenerated)
+    .api(generateExcelRoute, generateExcelDownload)
+    .api(downloadExcelRoute, downloadGeneratedExcel)
+    .api(generatePdfRoute, generatePdfDownload)
+    .api(downloadPdfRoute, downloadGeneratedPdf);
+}
+
+export default router;
+

package/hono/src/framework/maker-cli/stubs/example/route.plain.ts.stub

@@ -0,0 +1,18 @@
+import { group } from "@/framework/facade.js";
+import { downloadGenerated, downloadGeneratedExcel, downloadGeneratedPdf, fire, fireBroadcast, fireQueued, fireQueuedBroadcast, generateDownload, generateExcelDownload, generatePdfDownload, importExcel, queueCommand, upload } from "@/modules/{{module}}/controllers/{{module}}.controller.js";
+
+export default group()
+  .post("/event", fire)
+  .post("/queue/command", queueCommand)
+  .post("/event/queued", fireQueued)
+  .post("/event/queued-broadcast", fireQueuedBroadcast)
+  .post("/event/broadcast", fireBroadcast)
+  .post("/upload", upload)
+  .post("/import/excel", importExcel)
+  .post("/download/generate", generateDownload)
+  .get("/download/:token", downloadGenerated)
+  .post("/download/excel/generate", generateExcelDownload)
+  .get("/download/excel/:token", downloadGeneratedExcel)
+  .post("/download/pdf/generate", generatePdfDownload)
+  .get("/download/pdf/:requestId", downloadGeneratedPdf);
+

package/hono/src/framework/maker-cli/stubs/example/schema.plain.ts.stub

@@ -0,0 +1,42 @@
+import { z } from "@/framework/facade.js";
+
+export const ExampleEventSchema = z.object({
+  message: z.string(),
+  waitSeconds: z.number().optional()
+});
+
+export const UploadResponseSchema = z.object({
+  message: z.string(),
+  path: z.string(),
+  url: z.string()
+});
+
+export const DownloadTokenSchema = z.object({
+  message: z.string(),
+  token: z.string(),
+  downloadUrl: z.string()
+});
+
+export const ExcelDownloadRequestSchema = z.object({
+  title: z.string().min(2).max(100).default("Example Report")
+});
+
+export const QueueCommandRequestSchema = z.object({
+  message: z.string(),
+  waitSeconds: z.number().optional()
+});
+
+export const PdfGenerateRequestSchema = z.object({
+  title: z.string().min(2).max(100).default("Example PDF Report"),
+  rows: z.number().int().min(50).max(20000).default(1000),
+  chunkSize: z.number().int().min(50).max(1000).default(250)
+});
+
+export const PdfGenerateAcceptedSchema = z.object({
+  message: z.string(),
+  requestId: z.string(),
+  mode: z.enum(["queued", "inline"]),
+  statusUrl: z.string(),
+  downloadUrl: z.string()
+});
+

package/hono/src/framework/maker-cli/stubs/example/schema.ts.stub

@@ -0,0 +1,42 @@
+import { z } from "@hono/zod-openapi";
+
+export const ExampleEventSchema = z.object({
+  message: z.string(),
+  waitSeconds: z.number().optional()
+});
+
+export const UploadResponseSchema = z.object({
+  message: z.string(),
+  path: z.string(),
+  url: z.string()
+});
+
+export const DownloadTokenSchema = z.object({
+  message: z.string(),
+  token: z.string(),
+  downloadUrl: z.string()
+});
+
+export const ExcelDownloadRequestSchema = z.object({
+  title: z.string().min(2).max(100).default("Example Report")
+});
+
+export const QueueCommandRequestSchema = z.object({
+  message: z.string(),
+  waitSeconds: z.number().optional()
+});
+
+export const PdfGenerateRequestSchema = z.object({
+  title: z.string().min(2).max(100).default("Example PDF Report"),
+  rows: z.number().int().min(50).max(20000).default(1000),
+  chunkSize: z.number().int().min(50).max(1000).default(250)
+});
+
+export const PdfGenerateAcceptedSchema = z.object({
+  message: z.string(),
+  requestId: z.string(),
+  mode: z.enum(["queued", "inline"]),
+  statusUrl: z.string(),
+  downloadUrl: z.string()
+});
+

package/hono/src/framework/maker-cli/stubs/job/name.ts.stub

@@ -0,0 +1,25 @@
+import { DateTime } from "luxon";
+import { dispatchEvent, shouldQueue } from "@/framework/facade.js";
+
+/**
+ * event: Event name this worker listens to.
+ * queue: Queue name where jobs are consumed from.
+ * handler: Async processor that receives `job.data`.
+ */
+shouldQueue("{{module}}.{{name}}", "default", async job => {
+  console.log("{{module}}.{{name}}", job.data);
+
+  /**
+   * dispatchEvent name: Event id to publish to listeners.
+   * payload: Data sent to queue/broadcast consumers.
+   * queue: Optional queue target for async event consumers.
+   * broadcast: Optional realtime fanout (all/users/roles/rooms).
+   */
+  // await dispatchEvent("{{module}}.{{name}}.finished", {
+  //   ...job.data,
+  //   processedAt: DateTime.now(),
+  // });
+
+  return { ok: true, processedAt: DateTime.now().toISO() };
+});
+

package/hono/src/framework/maker-cli/stubs/middleware/name.ts.stub

@@ -0,0 +1,14 @@
+import type { Context, Next } from "hono";
+import { db } from "@/framework/facade.js";
+
+/**
+ * Why: Runs before route handlers to enforce cross-cutting rules for {{name}}.
+ * When: Attach to a route group or a specific route.
+ * Where: Add it to a group: group({{camel}}Middleware), or per route:
+ *        .api(route, [{{camel}}Middleware], handler)
+ * How: c.get("auth") is populated when authMiddleware ran first; db gives
+ *      typed access to your module models. Await next() to continue.
+ */
+export async function {{camel}}Middleware(c: Context, next: Next) {
+  return await next();
+}

package/hono/src/framework/maker-cli/stubs/model/name.mysql.ts.stub

@@ -0,0 +1,9 @@
+import { relations } from "drizzle-orm";
+import { int, mysqlTable, timestamp } from "drizzle-orm/mysql-core";
+
+export const {{tableVariable}} = mysqlTable("{{tableName}}", {
+  id: int("id").autoincrement().primaryKey(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+

package/hono/src/framework/maker-cli/stubs/model/name.postgresql.ts.stub

@@ -0,0 +1,9 @@
+import { relations } from "drizzle-orm";
+import { pgTable, serial, timestamp } from "drizzle-orm/pg-core";
+
+export const {{tableVariable}} = pgTable("{{tableName}}", {
+  id: serial("id").primaryKey(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+});
+

package/hono/src/framework/maker-cli/stubs/model/name.sqlite.ts.stub

@@ -0,0 +1,9 @@
+import { relations } from "drizzle-orm";
+import { integer, sqliteTable } from "drizzle-orm/sqlite-core";
+
+export const {{tableVariable}} = sqliteTable("{{tableName}}", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => new Date()).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => new Date()).notNull()
+});
+

package/hono/src/framework/maker-cli/stubs/notification/controller.ts.stub

@@ -0,0 +1,86 @@
+import type { Handler } from "hono";
+import { and, count, desc, eq, sql } from "drizzle-orm";
+import { db } from "@/framework/facade.js";
+import { notifications } from "@/modules/auth/database/models/notifications.js";
+
+export const list: Handler = async (c: any) => {
+  const userId = c.get("auth").id;
+  const page = Math.max(1, Number(c.req.query("page")) || 1);
+  const perPage = Math.min(50, Math.max(1, Number(c.req.query("perPage")) || 20));
+
+  const unread = await db.select({ count: count() }).from(notifications)
+    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
+
+  const total = await db.select({ count: count() }).from(notifications)
+    .where(eq(notifications.userId, userId));
+
+  const rows = await db.select().from(notifications)
+    .where(eq(notifications.userId, userId))
+    .orderBy(desc(notifications.createdAt))
+    .limit(perPage).offset((page - 1) * perPage);
+
+  return c.json({
+    data: rows.map(normalize),
+    total: total[0].count,
+    unread: unread[0].count,
+    page,
+    perPage,
+  });
+};
+
+export const unreadCount: Handler = async (c: any) => {
+  const userId = c.get("auth").id;
+  const rows = await db.select({ count: count() }).from(notifications)
+    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
+  return c.json({ count: rows[0].count });
+};
+
+export const markRead: Handler = async (c: any) => {
+  const userId = c.get("auth").id;
+  const id = Number(c.req.param("id"));
+
+  await db.update(notifications)
+    .set({ readAt: sql`now()` })
+    .where(and(eq(notifications.id, id), eq(notifications.userId, userId)));
+
+  return c.json({ ok: true });
+};
+
+export const markAllRead: Handler = async (c: any) => {
+  const userId = c.get("auth").id;
+
+  await db.update(notifications)
+    .set({ readAt: sql`now()` })
+    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
+
+  return c.json({ ok: true });
+};
+
+export const remove: Handler = async (c: any) => {
+  const userId = c.get("auth").id;
+  const id = Number(c.req.param("id"));
+
+  await db.delete(notifications)
+    .where(and(eq(notifications.id, id), eq(notifications.userId, userId)));
+
+  return c.json({ ok: true });
+};
+
+function normalize(row: typeof notifications.$inferSelect) {
+  let parsed: unknown = null;
+  if (row.data) {
+    try { parsed = JSON.parse(row.data); } catch {}
+  }
+  return {
+    id: row.id,
+    userId: row.userId,
+    type: row.type,
+    title: row.title,
+    body: row.body,
+    data: parsed,
+    link: row.link,
+    readAt: row.readAt?.toISOString() || null,
+    createdAt: row.createdAt.toISOString(),
+  };
+}
+

package/hono/src/framework/maker-cli/stubs/notification/job.ts.stub

@@ -0,0 +1,13 @@
+import { mail } from "@/framework/support/mail.js";
+import { logger } from "@/framework/support/logger.js";
+import { shouldQueue } from "@/framework/queue/queue.js";
+
+shouldQueue("{{module}}:mail", "mail", async (job) => {
+  const { to, subject, html } = job.data;
+
+  await mail.sendMail({ to, subject, html });
+  logger.info("Notification mail sent", { to, subject });
+
+  return { ok: true };
+});
+

package/hono/src/framework/maker-cli/stubs/notification/route.api.ts.stub

@@ -0,0 +1,50 @@
+import { createRoute, createRouter, HttpStatusCodes, jsonContent, z } from "@/framework/facade.js";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { list, unreadCount, markRead, markAllRead, remove } from "../controllers/{{module}}.controller.js";
+import { PaginatedNotificationsSchema, UnreadCountSchema } from "../controllers/{{module}}.schema.js";
+
+const listRoute = createRoute({
+  path: "/",
+  method: "get",
+  tags: ["Notifications"],
+  responses: { [HttpStatusCodes.OK]: jsonContent(PaginatedNotificationsSchema, "Paginated notifications") },
+});
+
+const unreadCountRoute = createRoute({
+  path: "/unread-count",
+  method: "get",
+  tags: ["Notifications"],
+  responses: { [HttpStatusCodes.OK]: jsonContent(UnreadCountSchema, "Unread count") },
+});
+
+const markReadRoute = createRoute({
+  path: "/{id}/read",
+  method: "patch",
+  tags: ["Notifications"],
+  request: { params: z.object({ id: z.coerce.number() }) },
+  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "Marked as read") },
+});
+
+const markAllReadRoute = createRoute({
+  path: "/read-all",
+  method: "patch",
+  tags: ["Notifications"],
+  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "All marked as read") },
+});
+
+const deleteRoute = createRoute({
+  path: "/{id}",
+  method: "delete",
+  tags: ["Notifications"],
+  request: { params: z.object({ id: z.coerce.number() }) },
+  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "Deleted") },
+});
+
+export default createRouter()
+  .group(authMiddleware)
+  .api(listRoute, list)
+  .api(unreadCountRoute, unreadCount)
+  .api(markReadRoute, markRead)
+  .api(markAllReadRoute, markAllRead)
+  .api(deleteRoute, remove);
+

package/hono/src/framework/maker-cli/stubs/notification/route.plain.ts.stub

@@ -0,0 +1,12 @@
+import { group } from "@/framework/facade.js";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { list, unreadCount, markRead, markAllRead, remove } from "../controllers/{{module}}.controller.js";
+
+export default group()
+  .use(authMiddleware)
+  .get("/", list)
+  .get("/unread-count", unreadCount)
+  .patch("/:id/read", markRead)
+  .patch("/read-all", markAllRead)
+  .delete("/:id", remove);
+

package/hono/src/framework/maker-cli/stubs/notification/schema.plain.ts.stub

@@ -0,0 +1,26 @@
+import { z } from "@/framework/facade.js";
+
+export const NotificationSchema = z.object({
+  id: z.number(),
+  userId: z.number(),
+  type: z.string(),
+  title: z.string(),
+  body: z.string().nullable(),
+  data: z.any().nullable(),
+  link: z.string().nullable(),
+  readAt: z.string().nullable(),
+  createdAt: z.string(),
+});
+
+export const UnreadCountSchema = z.object({
+  count: z.number(),
+});
+
+export const PaginatedNotificationsSchema = z.object({
+  data: z.array(NotificationSchema),
+  total: z.number(),
+  unread: z.number(),
+  page: z.number(),
+  perPage: z.number(),
+});
+

package/hono/src/framework/maker-cli/stubs/notification/schema.ts.stub

@@ -0,0 +1,26 @@
+import { z } from "@hono/zod-openapi";
+
+export const NotificationSchema = z.object({
+  id: z.number(),
+  userId: z.number(),
+  type: z.string(),
+  title: z.string(),
+  body: z.string().nullable(),
+  data: z.any().nullable(),
+  link: z.string().nullable(),
+  readAt: z.string().nullable(),
+  createdAt: z.string(),
+});
+
+export const UnreadCountSchema = z.object({
+  count: z.number(),
+});
+
+export const PaginatedNotificationsSchema = z.object({
+  data: z.array(NotificationSchema),
+  total: z.number(),
+  unread: z.number(),
+  page: z.number(),
+  perPage: z.number(),
+});
+

package/hono/src/framework/maker-cli/stubs/route/api.ts.stub

@@ -0,0 +1,80 @@
+import { createRoute, group, HttpStatusCodes, jsonContent } from "@/framework/facade.js";
+import { requireRole } from "@/middlewares/role-middleware.js";
+import { destroy, index, show, store, update } from "@/modules/{{module}}/controllers/{{controller}}.controller.js";
+import {
+  Create{{ClassName}}Schema,
+  {{ClassName}}IdParamsSchema,
+  {{ClassName}}ListResponseSchema,
+  {{ClassName}}MessageSchema,
+  {{ClassName}}ResponseSchema,
+  Update{{ClassName}}Schema
+} from "@/modules/{{module}}/controllers/{{controller}}.schema.js";
+
+const indexRoute = createRoute({
+  path: "/",
+  method: "get",
+  tags: ["{{ModuleClass}}"],
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent({{ClassName}}ListResponseSchema, "{{module}} list")
+  }
+});
+
+const showRoute = createRoute({
+  path: "/{id}",
+  method: "get",
+  tags: ["{{ModuleClass}}"],
+  request: {
+    params: {{ClassName}}IdParamsSchema
+  },
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent({{ClassName}}ResponseSchema, "{{module}} item"),
+    [HttpStatusCodes.NOT_FOUND]: jsonContent({{ClassName}}MessageSchema, "Not found")
+  }
+});
+
+const storeRoute = createRoute({
+  path: "/",
+  method: "post",
+  tags: ["{{ModuleClass}}"],
+  request: {
+    body: jsonContent(Create{{ClassName}}Schema, "Create {{module}} payload")
+  },
+  responses: {
+    [HttpStatusCodes.CREATED]: jsonContent({{ClassName}}MessageSchema, "Created")
+  }
+});
+
+const updateRoute = createRoute({
+  path: "/{id}",
+  method: "put",
+  tags: ["{{ModuleClass}}"],
+  request: {
+    params: {{ClassName}}IdParamsSchema,
+    body: jsonContent(Update{{ClassName}}Schema, "Update {{module}} payload")
+  },
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent({{ClassName}}MessageSchema, "Updated"),
+    [HttpStatusCodes.NOT_FOUND]: jsonContent({{ClassName}}MessageSchema, "Not found")
+  }
+});
+
+const destroyRoute = createRoute({
+  path: "/{id}",
+  method: "delete",
+  tags: ["{{ModuleClass}}"],
+  request: {
+    params: {{ClassName}}IdParamsSchema
+  },
+  responses: {
+    [HttpStatusCodes.OK]: jsonContent({{ClassName}}MessageSchema, "Deleted"),
+    [HttpStatusCodes.NOT_FOUND]: jsonContent({{ClassName}}MessageSchema, "Not found")
+  }
+});
+
+export default group()
+  .api(indexRoute, index)
+  .api(showRoute, show)
+  .api(storeRoute, store)
+  .api(updateRoute, update)
+  .api(destroyRoute, destroy);
+