@enderworld/onlyapi 1.5.1

package/src/presentation/handlers/auth.handler.ts

@@ -0,0 +1,218 @@
+import {
+  forgotPasswordDto,
+  loginDto,
+  logoutDto,
+  mfaDisableDto,
+  mfaEnableDto,
+  mfaVerifyDto,
+  refreshDto,
+  registerDto,
+  resetPasswordDto,
+  verifyEmailDto,
+} from "../../application/dtos/auth.dto.js";
+import type { AuthService } from "../../application/services/auth.service.js";
+import type { Logger } from "../../core/ports/logger.js";
+import type { TokenService } from "../../core/ports/token-service.js";
+import type { RequestContext } from "../context.js";
+import { authenticate } from "../middleware/auth.js";
+import { validateBody } from "../middleware/validate.js";
+import { createdResponse, errorResponse, jsonResponse, noContentResponse } from "./response.js";
+
+export const authHandlers = (
+  authService: AuthService,
+  tokenService: TokenService,
+  logger: Logger,
+) => ({
+  register: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(registerDto, body);
+    if (!validated.ok) {
+      logger.warn("Registration validation failed", {
+        requestId: ctx.requestId,
+        code: validated.error.code,
+      });
+      return errorResponse(validated.error, ctx.requestId);
+    }
+
+    const result = await authService.register(validated.value);
+    if (!result.ok) {
+      logger.warn("Registration failed", { requestId: ctx.requestId, code: result.error.code });
+      return errorResponse(result.error, ctx.requestId);
+    }
+
+    return createdResponse(result.value);
+  },
+
+  login: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(loginDto, body);
+    if (!validated.ok) {
+      logger.warn("Login validation failed", {
+        requestId: ctx.requestId,
+        code: validated.error.code,
+      });
+      return errorResponse(validated.error, ctx.requestId);
+    }
+
+    const result = await authService.login(validated.value);
+    if (!result.ok) {
+      logger.warn("Login failed", { requestId: ctx.requestId, code: result.error.code });
+      return errorResponse(result.error, ctx.requestId);
+    }
+
+    return jsonResponse(result.value);
+  },
+
+  refresh: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(refreshDto, body);
+    if (!validated.ok) {
+      logger.warn("Refresh validation failed", {
+        requestId: ctx.requestId,
+        code: validated.error.code,
+      });
+      return errorResponse(validated.error, ctx.requestId);
+    }
+
+    const result = await authService.refresh(validated.value);
+    if (!result.ok) {
+      logger.warn("Token refresh failed", { requestId: ctx.requestId, code: result.error.code });
+      return errorResponse(result.error, ctx.requestId);
+    }
+
+    return jsonResponse(result.value);
+  },
+
+  logout: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const authResult = await authenticate(req, tokenService);
+    if (!authResult.ok) {
+      logger.warn("Auth failed on logout", {
+        requestId: ctx.requestId,
+        code: authResult.error.code,
+      });
+      return errorResponse(authResult.error, ctx.requestId);
+    }
+
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(logoutDto, body);
+    if (!validated.ok) {
+      logger.warn("Logout validation failed", {
+        requestId: ctx.requestId,
+        code: validated.error.code,
+      });
+      return errorResponse(validated.error, ctx.requestId);
+    }
+
+    const authHeader = req.headers.get("authorization") ?? "";
+    const accessToken = authHeader.split(" ")[1] ?? "";
+
+    const result = await authService.logout({
+      ...validated.value,
+      accessToken,
+    });
+    if (!result.ok) {
+      logger.warn("Logout failed", { requestId: ctx.requestId, code: result.error.code });
+      return errorResponse(result.error, ctx.requestId);
+    }
+
+    return noContentResponse();
+  },
+
+  // ── v1.4 — Auth Platform handlers ──
+
+  verifyEmail: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(verifyEmailDto, body);
+    if (!validated.ok) return errorResponse(validated.error, ctx.requestId);
+
+    const result = await authService.verifyEmail(validated.value);
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    return jsonResponse({ message: "Email verified successfully" });
+  },
+
+  resendVerification: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const authResult = await authenticate(req, tokenService);
+    if (!authResult.ok) return errorResponse(authResult.error, ctx.requestId);
+
+    const result = await authService.resendVerification(authResult.value.sub);
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    return jsonResponse({ message: "Verification email sent", token: result.value.token });
+  },
+
+  forgotPassword: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(forgotPasswordDto, body);
+    if (!validated.ok) return errorResponse(validated.error, ctx.requestId);
+
+    const result = await authService.forgotPassword(validated.value);
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    // Always return success to prevent email enumeration
+    return jsonResponse({
+      message: "If this email exists, a reset link has been sent",
+      token: result.value.token,
+    });
+  },
+
+  resetPassword: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(resetPasswordDto, body);
+    if (!validated.ok) return errorResponse(validated.error, ctx.requestId);
+
+    const result = await authService.resetPassword(validated.value);
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    return jsonResponse({ message: "Password reset successfully" });
+  },
+
+  mfaSetup: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const authResult = await authenticate(req, tokenService);
+    if (!authResult.ok) return errorResponse(authResult.error, ctx.requestId);
+
+    const result = await authService.mfaSetup(authResult.value.sub, "");
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    return jsonResponse(result.value);
+  },
+
+  mfaEnable: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const authResult = await authenticate(req, tokenService);
+    if (!authResult.ok) return errorResponse(authResult.error, ctx.requestId);
+
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(mfaEnableDto, body);
+    if (!validated.ok) return errorResponse(validated.error, ctx.requestId);
+
+    const result = await authService.mfaEnable(authResult.value.sub, validated.value);
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    return jsonResponse({ message: "MFA enabled successfully" });
+  },
+
+  mfaDisable: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const authResult = await authenticate(req, tokenService);
+    if (!authResult.ok) return errorResponse(authResult.error, ctx.requestId);
+
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(mfaDisableDto, body);
+    if (!validated.ok) return errorResponse(validated.error, ctx.requestId);
+
+    const result = await authService.mfaDisable(authResult.value.sub, validated.value);
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    return jsonResponse({ message: "MFA disabled successfully" });
+  },
+
+  mfaVerify: async (req: Request, ctx: RequestContext): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(mfaVerifyDto, body);
+    if (!validated.ok) return errorResponse(validated.error, ctx.requestId);
+
+    const result = await authService.mfaVerify(validated.value);
+    if (!result.ok) return errorResponse(result.error, ctx.requestId);
+
+    return jsonResponse(result.value);
+  },
+});

package/src/presentation/handlers/health.handler.ts

@@ -0,0 +1,27 @@
+import type { HealthService } from "../../application/services/health.service.js";
+
+/**
+ * Health handler with two modes:
+ * - Deep check: full service health (for /readiness)
+ * - Shallow check: pre-serialized instant response (for /health and load balancer probes)
+ */
+export const healthHandler = (healthService: HealthService) => {
+  /** Pre-serialized shallow health — zero JSON.stringify per request */
+  const shallowHeaders = new Headers({
+    "Content-Type": "application/json; charset=utf-8",
+  });
+
+  const deepCheck = async (): Promise<Response> => {
+    const status = await healthService.check();
+    const httpCode = status.status === "ok" ? 200 : 503;
+    return Response.json({ data: status }, { status: httpCode });
+  };
+
+  const shallowCheck = (): Response => {
+    // Ultra-fast: pre-built body, avoids JSON.stringify + async overhead
+    const body = `{"data":{"status":"ok","uptime":${process.uptime()}}}`;
+    return new Response(body, { status: 200, headers: shallowHeaders });
+  };
+
+  return { deepCheck, shallowCheck };
+};

package/src/presentation/handlers/index.ts

@@ -0,0 +1,15 @@
+export { errorResponse, jsonResponse, createdResponse, noContentResponse } from "./response.js";
+export { healthHandler } from "./health.handler.js";
+export { authHandlers } from "./auth.handler.js";
+export { userHandlers } from "./user.handler.js";
+export { adminHandlers } from "./admin.handler.js";
+export { metricsHandler } from "./metrics.handler.js";
+export { apiKeyHandlers } from "./api-key.handler.js";
+export { oauthHandlers } from "./oauth.handler.js";
+export { webhookHandlers } from "./webhook.handler.js";
+export {
+  createWebSocketManager,
+  type WebSocketManager,
+  type WsConnectionData,
+} from "./websocket.handler.js";
+export { createSseHandler, type SseHandler } from "./sse.handler.js";

package/src/presentation/handlers/metrics.handler.ts

@@ -0,0 +1,21 @@
+/**
+ * Prometheus metrics HTTP handler — serves `GET /metrics` in text exposition format.
+ */
+
+import type { MetricsCollector } from "../../core/ports/metrics.js";
+
+const CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
+
+export const metricsHandler = (metrics: MetricsCollector) => {
+  const headers = new Headers({
+    "Content-Type": CONTENT_TYPE,
+    "Cache-Control": "no-store",
+  });
+
+  const serve = (): Response => {
+    const body = metrics.serialize();
+    return new Response(body, { status: 200, headers });
+  };
+
+  return { serve };
+};

package/src/presentation/handlers/oauth.handler.ts

@@ -0,0 +1,61 @@
+import { oauthCallbackDto } from "../../application/dtos/auth.dto.js";
+import type { AuthService } from "../../application/services/auth.service.js";
+import type { Logger } from "../../core/ports/logger.js";
+import type { OAuthProvider } from "../../core/ports/oauth.js";
+import type { RequestContext } from "../context.js";
+import { validateBody } from "../middleware/validate.js";
+import { errorResponse, jsonResponse } from "./response.js";
+
+export const oauthHandlers = (
+  authService: AuthService,
+  oauthProviders: ReadonlyMap<string, OAuthProvider>,
+  logger: Logger,
+) => ({
+  /**
+   * GET /api/v1/auth/oauth/:provider — redirect to provider's authorization URL
+   */
+  authorize: async (_req: Request, ctx: RequestContext, provider: string): Promise<Response> => {
+    const oauthProvider = oauthProviders.get(provider);
+    if (!oauthProvider) {
+      const body = `{"error":{"code":"NOT_FOUND","message":"Unknown provider: ${provider}"}}`;
+      return new Response(body, {
+        status: 404,
+        headers: { "Content-Type": "application/json; charset=utf-8" },
+      });
+    }
+
+    // Generate a state parameter for CSRF protection
+    const state = crypto.randomUUID();
+    const redirectUri = `${ctx.path.replace(`/oauth/${provider}`, `/oauth/${provider}/callback`)}`;
+
+    const url = oauthProvider.getAuthorizationUrl(state, redirectUri);
+    logger.info("OAuth redirect", { provider, requestId: ctx.requestId });
+
+    return new Response(null, {
+      status: 302,
+      headers: { Location: url },
+    });
+  },
+
+  /**
+   * POST /api/v1/auth/oauth/:provider/callback — exchange code for tokens
+   */
+  callback: async (req: Request, ctx: RequestContext, provider: string): Promise<Response> => {
+    const body = await req.json().catch(() => null);
+    const validated = validateBody(oauthCallbackDto, body);
+    if (!validated.ok) return errorResponse(validated.error, ctx.requestId);
+
+    const redirectUri = `${ctx.path}`;
+    const result = await authService.oauthLogin(provider, validated.value.code, redirectUri);
+    if (!result.ok) {
+      logger.warn("OAuth callback failed", {
+        provider,
+        requestId: ctx.requestId,
+        code: result.error.code,
+      });
+      return errorResponse(result.error, ctx.requestId);
+    }
+
+    return jsonResponse(result.value);
+  },
+});