create-nexgen 1.0.4

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

@@ -0,0 +1,206 @@
+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/template/src/framework/maker-cli/stubs/example/schema.ts.stub

@@ -0,0 +1,41 @@
+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/template/src/framework/maker-cli/stubs/job/name.ts.stub

@@ -0,0 +1,24 @@
+import { DateTime } from "luxon";
+import { shouldQueue, dispatchEvent } 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/template/src/framework/maker-cli/stubs/model/name.mysql.ts.stub

@@ -0,0 +1,8 @@
+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/template/src/framework/maker-cli/stubs/model/name.postgresql.ts.stub

@@ -0,0 +1,8 @@
+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/template/src/framework/maker-cli/stubs/model/name.sqlite.ts.stub

@@ -0,0 +1,8 @@
+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/template/src/framework/maker-cli/stubs/notification/NotificationBell.vue.stub

@@ -0,0 +1,218 @@
+<template>
+  <div class="btn-group order-3" ref="dropdownRef">
+    <button
+      type="button"
+      class="nav-btn position-relative"
+      data-bs-toggle="dropdown"
+      data-bs-display="static"
+      aria-expanded="false"
+      aria-label="notifications">
+      <i class="bi bi-bell"></i>
+      <span v-if="unread > 0" class="badge bg-danger notification-badge position-absolute" style="top:7.5%; right: 7.5%;">{{ unread > 99 ? '99+' : unread }}</span>
+    </button>
+    <div class="dropdown-menu notification-dropdown p-0">
+      <div class="dropdown-header d-flex align-items-center justify-content-between px-3 py-2">
+        <span class="fw-semibold">Notifications</span>
+        <button v-if="unread > 0" class="btn btn-sm btn-link p-0 text-decoration-none" @click="markAllRead">
+          Mark all read
+        </button>
+      </div>
+      <div class="notification-list">
+        <div v-if="items.length === 0" class="text-center text-secondary py-4 px-3">
+          No notifications
+        </div>
+        <div
+          v-for="item in items"
+          :key="item.id"
+          class="notification-item"
+          :class="{ unread: !item.readAt }"
+          @click="handleClick(item)">
+          <div class="d-flex align-items-start gap-2">
+            <i :class="iconClass(item.type)" class="mt-1"></i>
+            <div class="flex-grow-1 min-w-0">
+              <div class="notification-title">{{ item.title }}</div>
+              <div v-if="item.body" class="notification-body">{{ item.body }}</div>
+              <div class="notification-time">{{ timeAgo(item.createdAt) }}</div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <router-link to="/notifications" class="dropdown-footer d-block text-center py-2 text-decoration-none">
+        View all notifications
+      </router-link>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, onMounted, onUnmounted } from "vue";
+import axios from "@/plugins/axios";
+import { pulse } from "@/plugins/pulse";
+import { useAuth } from "@/composables/useAuth";
+
+const { user } = useAuth();
+
+const unread = ref(0);
+const items = ref<Array<{
+  id: number;
+  type: string;
+  title: string;
+  body: string | null;
+  link: string | null;
+  readAt: string | null;
+  createdAt: string;
+}>>([]);
+
+function iconClass(type: string) {
+  const map: Record<string, string> = {
+    info: "bi bi-info-circle text-primary",
+    success: "bi bi-check-circle text-success",
+    warning: "bi bi-exclamation-triangle text-warning",
+    error: "bi bi-x-circle text-danger",
+  };
+  return map[type] || "bi bi-bell text-secondary";
+}
+
+function timeAgo(dateStr: string) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  if (mins < 1) return "Just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+async function fetchUnread() {
+  try {
+    const res = await axios.get("/api/{{module}}/unread-count");
+    unread.value = res.data.count;
+  } catch {}
+}
+
+async function fetchRecent() {
+  try {
+    const res = await axios.get("/api/{{module}}?perPage=5");
+    items.value = res.data.data;
+    unread.value = res.data.unread;
+  } catch {}
+}
+
+async function markAllRead() {
+  try {
+    await axios.patch("/api/{{module}}/read-all");
+    items.value.forEach((n) => (n.readAt = new Date().toISOString()));
+    unread.value = 0;
+  } catch {}
+}
+
+function handleClick(item: any) {
+  if (!item.readAt) {
+    axios.patch(`/api/{{module}}/${item.id}/read`).catch(() => {});
+    item.readAt = new Date().toISOString();
+    unread.value = Math.max(0, unread.value - 1);
+  }
+}
+
+let cleanup: (() => void) | null = null;
+
+onMounted(async () => {
+  await fetchRecent();
+
+  if (user.value) {
+    const channel = pulse.channel(`user:${user.value.id}`);
+    channel.listen("notification.created", (payload: any) => {
+      items.value.unshift(payload);
+      unread.value++;
+    });
+    cleanup = () => channel.stopListening("notification.created");
+  }
+});
+
+onUnmounted(() => {
+  cleanup?.();
+});
+</script>
+
+<style scoped>
+.notification-badge {
+  font-size: 0.6rem;
+  padding: 0.15rem 0.35rem;
+  position: absolute;
+  top: 4px;
+  right: 2px;
+  min-width: 16px;
+  border-radius: 8px;
+}
+
+.notification-dropdown {
+  width: 360px;
+  max-height: 480px;
+}
+
+@media (max-width: 575.98px) {
+  .notification-dropdown {
+    position: fixed !important;
+    top: 56px;
+    left: 50% !important;
+    transform: translateX(-50%) !important;
+    width: calc(100vw - 32px);
+    max-width: 400px;
+  }
+}
+
+@media (min-width: 576px) {
+  .notification-dropdown {
+    left: auto !important;
+    right: 0 !important;
+    transform: none !important;
+  }
+}
+
+.notification-list {
+  max-height: 360px;
+  overflow-y: auto;
+}
+
+.notification-item {
+  padding: 0.75rem 1rem;
+  cursor: pointer;
+  border-bottom: 1px solid var(--app-border);
+  transition: background 0.15s;
+}
+
+.notification-item:hover {
+  background: var(--app-surface);
+}
+
+.notification-item.unread {
+  background: rgba(var(--bs-primary-rgb), 0.04);
+}
+
+.notification-title {
+  font-size: 0.85rem;
+  font-weight: 500;
+  line-height: 1.3;
+}
+
+.notification-body {
+  font-size: 0.8rem;
+  color: var(--bs-secondary-color);
+  margin-top: 0.15rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.notification-time {
+  font-size: 0.7rem;
+  color: var(--bs-secondary-color);
+  margin-top: 0.2rem;
+}
+
+.dropdown-footer {
+  font-size: 0.85rem;
+  border-top: 1px solid var(--app-border);
+}
+</style>

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

@@ -0,0 +1,85 @@
+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(),
+  };
+}