create-nexwire 4.2.5 → 4.4.0

package/express/src/framework/http/app.ts

@@ -30,6 +30,30 @@ export function createHttpApp() {
     next();
   });
 
+  if (appConfig.openApiEnabled) {
+    configureOpenApi(app);
+    registerOpenApiRoute(
+      createRoute({
+        path: "/health",
+        method: "get",
+        tags: ["System"],
+        responses: {
+          200: jsonContent(z.object({ message: z.string() }), "Application health status")
+        }
+      })
+    );
+
+    app.get("/health", (_req, res) => {
+      res.json({ message: "Application is healthy" });
+    });
+  }
+
+  if (loggingConfig.httpRequests) {
+    app.use(loggerMiddleware);
+  }
+
+  app.use(rateLimiterMiddleware);
+
   app.get("/ready", (_req, res) => {
     const checks: Record<string, string> = {};
     let allOk = true;
@@ -71,30 +95,12 @@ export function createHttpApp() {
     res.type("text/plain").status(200).send(output);
   });
 
-  if (loggingConfig.httpRequests) {
-    app.use(loggerMiddleware);
-  }
-
-  app.use(rateLimiterMiddleware);
-
-  if (appConfig.openApiEnabled) {
-    configureOpenApi(app);
-    registerOpenApiRoute(
-      createRoute({
-        path: "/health",
-        method: "get",
-        tags: ["System"],
-        responses: {
-          200: jsonContent(z.object({ message: z.string() }), "Application health status")
-        }
-      })
-    );
+  if (!appConfig.openApiEnabled) {
+    app.get("/health", (_req, res) => {
+      res.json({ message: "Application is healthy" });
+    });
   }
 
-  app.get("/health", (_req, res) => {
-    res.json({ message: "Application is healthy" });
-  });
-
   if (!hasUiBuild()) {
     app.get("/", (_req, res) => {
       res.json({ name: appConfig.name, ok: true });

package/express/src/framework/http/logger.ts

@@ -1,5 +1,6 @@
 import type { ErrorRequestHandler, RequestHandler } from "express";
 import createError from "http-errors";
+import { openApiConfig } from "@/config/index.js";
 import { logger } from "@/framework/support/logger.js";
 
 function requestIp(req: Parameters<RequestHandler>[0]) {
@@ -7,6 +8,21 @@ function requestIp(req: Parameters<RequestHandler>[0]) {
   return String(req.headers["cf-connecting-ip"] || forwarded || req.headers["x-real-ip"] || req.socket.remoteAddress || "");
 }
 
+// Express has no "route registered before the logger" behaviour to lean on, so
+// the skips are explicit: probes, the queue dashboard, favicon and OpenAPI
+// assets.
+const PROBE_PATHS = new Set(["/health", "/ready", "/live"]);
+
+function shouldSkipHttpLog(pathname: string) {
+  return (
+    PROBE_PATHS.has(pathname) ||
+    pathname.startsWith("/queues") ||
+    pathname === "/favicon.ico" ||
+    pathname === openApiConfig.scalar.specUrl ||
+    pathname === openApiConfig.scalar.docsPath
+  );
+}
+
 export const loggerMiddleware: RequestHandler = (req, res, next) => {
   const startedAt = Date.now();
   const requestId = crypto.randomUUID();
@@ -15,19 +31,22 @@ export const loggerMiddleware: RequestHandler = (req, res, next) => {
   res.setHeader("X-Request-ID", requestId);
 
   res.on("finish", () => {
-    const pathname = (req.url ?? "").split("?")[0];
-    if (pathname === "/health" || pathname.startsWith("/queues")) return;
-
-    logger.info("HTTP Request", {
-      requestId,
-      method: req.method,
-      path: pathname,
-      url: req.originalUrl,
-      status: res.statusCode,
-      duration_ms: Date.now() - startedAt,
-      ip: requestIp(req),
-      userAgent: req.headers["user-agent"] || null
-    });
+    // req.originalUrl ব্যবহার করুন, কারণ req.url রাউটারের ভেতরে বদলে যায়
+    const pathname = (req.originalUrl || req.url || "").split("?")[0];
+
+    // shouldSkipHttpLog চেক করুন
+    if (!shouldSkipHttpLog(pathname)) {
+      logger.info("HTTP Request", {
+        requestId,
+        method: req.method,
+        path: pathname,
+        url: req.originalUrl,
+        status: res.statusCode,
+        duration_ms: Date.now() - startedAt,
+        ip: requestIp(req),
+        userAgent: req.headers["user-agent"] || null
+      });
+    }
   });
 
   next();
@@ -45,6 +64,7 @@ export const onError: ErrorRequestHandler = (error, _req, res, _next) => {
       status,
       issues: error.error.issues
     });
+
     res.status(status).json({
       success: false,
       error: {
@@ -52,18 +72,18 @@ export const onError: ErrorRequestHandler = (error, _req, res, _next) => {
         issues: error.error.issues
       }
     });
+
     return;
   }
 
   const message = status === 500 && !error?.expose ? "Internal server error" : (error?.message ?? "Internal server error");
   const stack = process.env.NODE_ENV === "production" ? undefined : error?.stack;
+
   logger.error("Request failed", {
     status,
     message,
     stack: error?.stack
   });
-  res.status(status).json({
-    message,
-    ...(stack ? { stack } : {})
-  });
+
+  res.status(status).json({ message, ...(stack ? { stack } : {}) });
 };

package/express/src/framework/http/openapi.ts

@@ -28,27 +28,25 @@ export function createOpenApiDocument() {
 }
 
 export function configureOpenApi(app: Express) {
-  app.get(openApiConfig.scalar.specUrl, (_req, res) => {
+  const { specUrl, docsPath, favicon, ...scalarOptions } = openApiConfig.scalar;
+
+  app.get(specUrl, (_req, res) => {
     res.json(createOpenApiDocument());
   });
 
-  if (openApiConfig.scalar.favicon) {
+  if (favicon) {
     app.get("/favicon.ico", (_req, res) => {
-      const faviconPath = path.join(process.cwd(), openApiConfig.scalar.favicon);
+      const faviconPath = path.join(process.cwd(), favicon);
       if (!fs.existsSync(faviconPath)) return res.status(404).end();
       res.type("image/x-icon").sendFile(faviconPath);
     });
   }
 
   app.get(
-    openApiConfig.scalar.docsPath,
+    docsPath,
     apiReference({
-      url: openApiConfig.scalar.specUrl,
-      layout: openApiConfig.scalar.layout,
-      theme: openApiConfig.scalar.theme,
-      pageTitle: openApiConfig.scalar.pageTitle,
-      defaultHttpClient: openApiConfig.scalar.defaultHttpClient,
-      defaultOpenAllTags: openApiConfig.scalar.defaultOpenAllTags
-    } as any)
+      url: specUrl, // Map specUrl to url
+      ...scalarOptions // Pass EVERYTHING else automatically!
+    } as any) // The `as any` might still be needed if Express types are slightly behind
   );
 }

package/express/src/framework/maker-cli/runtime/core.mjs

@@ -120,7 +120,7 @@ function serveRedisUnavailablePage(port, endpoint) {
 </html>
 `;
 
-  return new Promise((resolve, reject) => {
+  return new Promise((_resolve, reject) => {
     const server = http.createServer((_req, res) => {
       res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
       res.end(body);
@@ -558,4 +558,3 @@ export async function clearViteCache() {
 
   console.log("Vite cache cleared.");
 }
-

package/express/src/framework/modules/routes.ts

@@ -1,21 +1,26 @@
-import type { Express } from "express";
-import { registerRouterOpenApi } from "@/framework/http/router.js";
-import { discoverModuleFiles, importFile, moduleNameFromPath } from "@/framework/modules/discover.js";
-
-export async function registerModuleRoutes(app: Express) {
-  const files = await discoverModuleFiles("**/routes/*.{ts,js}");
-
-  for (const file of files) {
-    const route = await importFile(file);
-
-    if (!route.default) {
-      throw new Error(`Route file ${file} has no default export`);
-    }
-
-    const prefix = `/api/${moduleNameFromPath(file)}`;
-    registerRouterOpenApi(route.default, prefix);
-    app.use(prefix, route.default);
-  }
-
-  return files.length;
-}
+import type { Express } from "express";
+import { registerRouterOpenApi } from "@/framework/http/router.js";
+import { discoverModuleFiles, importFile, moduleNameFromPath } from "@/framework/modules/discover.js";
+
+export async function registerModuleRoutes(app: Express) {
+  const files = await discoverModuleFiles("**/routes/*.{ts,js}");
+
+  for (const file of files) {
+    const route = await importFile(file);
+
+    if (!route.default) {
+      throw new Error(`Route file ${file} has no default export`);
+    }
+
+    // Optional Guard: Ensure it's an Express Router
+    if (typeof route.default !== "function" || !route.default.stack) {
+      throw new Error(`Route file ${file} must export an express.Router() instance as default`);
+    }
+
+    const prefix = `/api/${moduleNameFromPath(file)}`;
+    registerRouterOpenApi(route.default, prefix);
+    app.use(prefix, route.default);
+  }
+
+  return files.length;
+}

package/express/src/framework/notification/channels/broadcast.ts

@@ -0,0 +1,15 @@
+import { dispatchEvent } from "@/framework/events/dispatcher.js";
+import type { NotificationChannel } from "@/framework/notification/contracts.js";
+
+export const broadcastChannel: NotificationChannel = {
+  name: "broadcast",
+  async send(target, notification, options) {
+    if (!options.broadcast) return false;
+
+    await dispatchEvent("notification.created", notification, {
+      broadcast: { users: [target.id] }
+    });
+
+    return true;
+  }
+};

package/express/src/framework/notification/channels/mail.ts

@@ -0,0 +1,42 @@
+import { dispatchEvent } from "@/framework/events/dispatcher.js";
+import type { NotificationChannel } from "@/framework/notification/contracts.js";
+import { resolveAuthProvider } from "@/framework/providers/adapter.js";
+import { redisClientIfReady } from "@/framework/redis/client.js";
+import { mail } from "@/framework/support/mail.js";
+
+function escapeHtml(str: string) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+export const mailChannel: NotificationChannel = {
+  name: "mail",
+  async send(target, notification, options) {
+    if (!options.mail) return false;
+
+    let to = options.mail.to || null;
+    if (!to) {
+      try {
+        const provider = await resolveAuthProvider();
+        if (provider?.getUserContact) {
+          const contact = await provider.getUserContact(target.id);
+          if (contact?.email) to = contact.email as string;
+        }
+      } catch {}
+    }
+
+    if (!to) return false;
+
+    const subject = options.mail.subject || notification.title;
+    const html =
+      options.mail.html ||
+      `<h2>${escapeHtml(notification.title)}</h2>${notification.body ? `<p>${escapeHtml(notification.body)}</p>` : ""}`;
+
+    if (redisClientIfReady()) {
+      await dispatchEvent("notification:mail", { to, subject, html }, { queue: "mail" });
+    } else {
+      await mail.sendMail({ to, subject, html });
+    }
+
+    return true;
+  }
+};

package/express/src/framework/notification/contracts.ts

@@ -0,0 +1,29 @@
+import type { NotifiableTarget, NotificationRecord } from "@/framework/providers/contracts.js";
+
+export type NotificationTarget = number | string | NotifiableTarget;
+export type NormalizedTarget = { type: string; id: number | string };
+
+export type NotificationOptions = {
+  type?: string;
+  title: string;
+  body?: string;
+  link?: string;
+  data?: Record<string, unknown>;
+
+  // Built-in Channels
+  broadcast?: boolean;
+  mail?: {
+    to?: string;
+    subject?: string;
+    html?: string;
+  };
+
+  // Extensible: Add any custom channel options here (e.g., sms, push, discord)
+  sms?: { to?: string; message?: string };
+  push?: { token?: string; payload?: any };
+};
+
+export interface NotificationChannel {
+  name: string;
+  send(target: NormalizedTarget, notification: NotificationRecord, options: NotificationOptions): Promise<boolean>;
+}

package/express/src/framework/notification/index.ts

@@ -1,39 +1,12 @@
-import { dispatchEvent } from "@/framework/events/dispatcher.js";
-import { resolveAuthProvider, resolveNotificationProvider } from "@/framework/providers/adapter.js";
-import type { NotifiableTarget, NotificationRecord } from "@/framework/providers/contracts.js";
-import { redisClientIfReady } from "@/framework/redis/client.js";
-import { mail } from "@/framework/support/mail.js";
+import type { NormalizedTarget, NotificationOptions, NotificationTarget } from "@/framework/notification/contracts.js";
+import { getChannels } from "@/framework/notification/registry.js";
+import { resolveNotificationProvider } from "@/framework/providers/adapter.js";
+import type { NotificationRecord } from "@/framework/providers/contracts.js";
 
 let missingProviderWarned = false;
 
-/** A numeric id (default auth), a string id (UUID/ULID), or an explicit target. */
-export type NotificationTarget = number | string | NotifiableTarget;
-
-/** Extra JSON metadata attached to the notification (e.g. entity IDs, links). */
-export type NotificationOptions = {
-  /** Notification category key (default: "info") */
-  type?: string;
-  /** Notification title */
-  title: string;
-  /** Notification body text */
-  body?: string;
-  /** Optional click-through URL */
-  link?: string;
-  /** Arbitrary JSON payload stored in `data` column */
-  data?: Record<string, unknown>;
-  /** Whether to broadcast the notification to the user's socket in realtime */
-  broadcast?: boolean;
-  /** Email delivery options */
-  mail?: {
-    /** Explicit recipient. Skips the auth provider contact lookup. */
-    to?: string;
-    subject?: string;
-    html?: string;
-  };
-};
-
 /** Turn the public target argument into the polymorphic owner pair. */
-function normalizeTarget(target: NotificationTarget): Required<Pick<NotifiableTarget, "id">> & { type: string } {
+function normalizeTarget(target: NotificationTarget): NormalizedTarget {
   if (target !== null && typeof target === "object") {
     return {
       type: String(target.type || "user").trim() || "user",
@@ -44,13 +17,10 @@ function normalizeTarget(target: NotificationTarget): Required<Pick<NotifiableTa
 }
 
 /**
- * Why: Persists a notification through the registered provider.
- * When: A feature wants to record something for a user (or another notifiable).
+ * Why: Persists a notification to the database and triggers all active channels.
+ * When: A feature wants to record something for a user.
  * Where: Application code, through the framework facade.
- * How: The provider owns storage; broadcasting and email stay here so a custom
- *      store cannot silently disable them. A missing provider is reported once
- *      and returns `null` instead of throwing, matching the framework's
- *      "optional module" behaviour.
+ * How: The provider owns database storage. The channels handle delivery (mail, sms, ws).
  */
 export async function notify(target: NotificationTarget, options: NotificationOptions): Promise<NotificationRecord | null> {
   const provider = await resolveNotificationProvider();
@@ -65,6 +35,8 @@ export async function notify(target: NotificationTarget, options: NotificationOp
   }
 
   const normalizedTarget = normalizeTarget(target);
+
+  // 1. Save to Database via the Provider
   const normalized = await provider.create(normalizedTarget, {
     type: options.type,
     title: options.title,
@@ -73,62 +45,15 @@ export async function notify(target: NotificationTarget, options: NotificationOp
     data: options.data ?? null
   });
 
-  if (options.broadcast) {
-    await dispatchEvent("notification.created", normalized, {
-      broadcast: { users: [normalizedTarget.id] }
-    });
-  }
-
-  if (options.mail) {
-    await sendMailChannel(normalizedTarget, normalized, options);
-  }
+  // 2. Dispatch to all registered channels in parallel
+  const channels = getChannels();
+  await Promise.allSettled(
+    channels.map((channel) =>
+      channel.send(normalizedTarget, normalized, options).catch((err) => {
+        console.error(`[notification] Channel ${channel.name} failed:`, err);
+      })
+    )
+  );
 
   return normalized;
 }
-
-/** Deliver an email notification, either queued (if Redis is available) or direct. */
-async function sendMailChannel(
-  target: { type: string; id: number | string },
-  notification: NotificationRecord,
-  options: NotificationOptions
-) {
-  let to: string | null = options.mail?.to || null;
-
-  if (!to) {
-    try {
-      const provider = await resolveAuthProvider();
-      if (provider?.getUserContact) {
-        const contact = await provider.getUserContact(target.id);
-        if (contact?.email) to = contact.email as string;
-      }
-    } catch {}
-  }
-
-  if (!to) return;
-
-  const subject = options.mail?.subject || notification.title;
-  const html = options.mail?.html || defaultMailHtml(notification.title, notification.body);
-
-  if (redisClientIfReady()) {
-    await dispatchEvent(
-      "notification:mail",
-      {
-        to,
-        subject,
-        html
-      },
-      { queue: "mail" }
-    );
-  } else {
-    await mail.sendMail({ to, subject, html });
-  }
-}
-
-/** Generate a basic HTML email body from title and body text. */
-function defaultMailHtml(title: string, body: string | null) {
-  return `<h2>${escapeHtml(title)}</h2>${body ? `<p>${escapeHtml(body)}</p>` : ""}`;
-}
-
-function escapeHtml(str: string) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}

package/express/src/framework/notification/registry.ts

@@ -0,0 +1,15 @@
+import type { NotificationChannel } from "@/framework/notification/contracts.js";
+
+const channels = new Map<string, NotificationChannel>();
+
+export function registerChannel(channel: NotificationChannel) {
+  channels.set(channel.name, channel);
+}
+
+export function getChannels(): NotificationChannel[] {
+  return Array.from(channels.values());
+}
+
+export function clearChannels() {
+  channels.clear();
+}

package/express/src/framework/providers/adapter.ts

@@ -18,6 +18,7 @@ async function loadDefaultProvider(): Promise<AuthProvider | null> {
   if (defaultProvider) return defaultProvider;
   if (defaultLoadAttempted) return null;
   defaultLoadAttempted = true;
+
   try {
     const userMod = await import("@/modules/auth/database/models/user.js").catch(() => null);
     if (!userMod?.users || !userMod?.refreshTokens) return null;
@@ -25,22 +26,28 @@ async function loadDefaultProvider(): Promise<AuthProvider | null> {
     const users = userMod.users;
     const refreshTokens = userMod.refreshTokens;
 
-    defaultProvider = {
-      async getUserById(id: number | string) {
-        try {
-          const user = await (db.query.users.findFirst as any)?.({
-            where: eq(users.id, id as any),
-            with: { role: true }
-          });
-          if (user) return user;
-        } catch {}
-        try {
-          const rows = await db.select().from(users).where(eq(users.id, id as any));
-          return rows?.[0] ?? null;
-        } catch {
-          return null;
-        }
-      },
+    // Define the core logic as standalone functions to avoid `this` context issues
+    const getUserById = async (id: number | string) => {
+      try {
+        const user = await (db.query.users.findFirst as any)?.({
+          where: eq(users.id, id as any),
+          with: { role: true }
+        });
+        if (user) return user;
+      } catch {}
+      try {
+        const rows = await db
+          .select()
+          .from(users)
+          .where(eq(users.id, id as any));
+        return rows?.[0] ?? null;
+      } catch {
+        return null;
+      }
+    };
+
+    const provider: AuthProvider = {
+      getUserById,
       async findRefreshToken(jti: string) {
         try {
           const token = await (db.query.refreshTokens.findFirst as any)?.({
@@ -89,7 +96,8 @@ async function loadDefaultProvider(): Promise<AuthProvider | null> {
       },
       async getUserContact(userId: number | string) {
         try {
-          const user = await this.getUserById(userId);
+          // Use the standalone function instead of `this.getUserById`
+          const user = await getUserById(userId);
           if (!user) return null;
           return {
             email: user.email ?? null,
@@ -101,6 +109,8 @@ async function loadDefaultProvider(): Promise<AuthProvider | null> {
         }
       }
     };
+
+    defaultProvider = provider;
     return defaultProvider;
   } catch {
     return null;