@de-otio/trellis 0.7.0 → 0.9.0

package/dist/lib/routes/dashboard.js

@@ -1,82 +1,45 @@
-"use strict";
 /**
  * Dashboard Routes
  *
  * Routes for internal dashboard, partner dashboard, and admin features
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dashboardRoutes = void 0;
-const db_1 = require("../../db");
-const worker_1 = require("../../worker");
-const database_connection_manager_1 = require("../database-connection-manager");
-const db_query_helper_1 = require("../db-query-helper");
-const logger_1 = require("../logger");
-const middleware_1 = require("../middleware");
-const region_detection_1 = require("../region-detection");
-const secret_resolver_1 = require("../secret-resolver");
-const security_headers_1 = require("../security-headers");
-const session_manager_1 = require("../session-manager");
-exports.dashboardRoutes = [
+import { createPrisma } from "../../db.js";
+import { addCorsHeaders } from "../../worker.js";
+import { sharedDatabaseConnectionManager } from "../database-connection-manager.js";
+import { QueryTimeoutPresets, withQueryTimeoutAndRetry, } from "../db-query-helper.js";
+import { getLogger } from "../logger.js";
+import { corsMiddleware, csrfMiddleware } from "../middleware.js";
+import { detectRegionSync } from "../region-detection.js";
+import { SecurityHeaders } from "../security-headers.js";
+import { SessionManager } from "../session-cookie.js";
+export const dashboardRoutes = [
     // Internal Dashboard - Statistics
     {
         path: "/api/dashboard/metrics/users",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Parse query parameters
                 const url = new URL(request.url);
@@ -141,49 +104,49 @@ exports.dashboardRoutes = [
                     changeType,
                     trend,
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting user metrics:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get user metrics" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get user metrics (DAU/WAU/MAU)",
     },
     {
         path: "/api/dashboard/system/health",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Test database connection
                 let dbStatus = "healthy";
                 let dbUptime = 99.9;
                 try {
-                    await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                    await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                         await db.user.count();
                     }, { timeoutMs: 2000, retryTimeoutMs: 1000 });
                 }
@@ -208,43 +171,43 @@ exports.dashboardRoutes = [
                         },
                     ],
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting system health:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get system health" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get system health status",
     },
     {
         path: "/api/dashboard/metrics/performance",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Parse query parameters
                 const url = new URL(request.url);
@@ -263,15 +226,15 @@ exports.dashboardRoutes = [
                         errorRate: [],
                     },
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting performance metrics:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get performance metrics" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get API performance metrics",
     },
     // User Management
@@ -279,28 +242,28 @@ exports.dashboardRoutes = [
         path: "/api/dashboard/users",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Parse query parameters
                 const url = new URL(request.url);
@@ -329,7 +292,7 @@ exports.dashboardRoutes = [
                 }
                 // Get users
                 const [users, total] = await Promise.all([
-                    (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                    withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                         return db.user.findMany({
                             where,
                             select: {
@@ -343,10 +306,10 @@ exports.dashboardRoutes = [
                             skip: offset,
                             orderBy: { createdAt: "desc" },
                         });
-                    }, db_query_helper_1.QueryTimeoutPresets.STANDARD),
-                    (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                    }, QueryTimeoutPresets.STANDARD),
+                    withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                         return db.user.count({ where });
-                    }, db_query_helper_1.QueryTimeoutPresets.STANDARD),
+                    }, QueryTimeoutPresets.STANDARD),
                 ]);
                 const response = securityHeaders.createSecureResponse(JSON.stringify({
                     users: users.map((u) => ({
@@ -358,53 +321,53 @@ exports.dashboardRoutes = [
                     })),
                     total,
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error listing users:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to list users" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "List users with search and filtering",
     },
     {
         path: /^\/api\/dashboard\/users\/(.+)$/,
         method: "GET",
         handler: async (request, env, { pathname }) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Extract user ID from path
                 const userIdMatch = pathname.match(/^\/api\/dashboard\/users\/(.+)$/);
                 if (!userIdMatch) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Invalid user ID" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const userId = userIdMatch[1];
                 // Get user details
-                const targetUser = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const targetUser = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: userId },
                         select: {
@@ -415,10 +378,10 @@ exports.dashboardRoutes = [
                             createdAt: true,
                         },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!targetUser) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "User not found" }), { status: 404, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Get user stats (post count, comment count, etc.)
                 // TODO: Implement actual stats calculation
@@ -434,49 +397,49 @@ exports.dashboardRoutes = [
                     createdAt: targetUser.createdAt.toISOString(),
                     stats,
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting user details:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get user details" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get detailed user information",
     },
     {
         path: /^\/api\/dashboard\/users\/(.+)$/,
         method: "PATCH",
         handler: async (request, env, { pathname }) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Extract user ID from path
                 const userIdMatch = pathname.match(/^\/api\/dashboard\/users\/(.+)$/);
                 if (!userIdMatch) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Invalid user ID" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const userId = userIdMatch[1];
                 // Parse request body
@@ -496,7 +459,7 @@ exports.dashboardRoutes = [
                     ];
                     if (!validRoles.includes(role)) {
                         const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Invalid role" }), { status: 400, headers: { "content-type": "application/json" } });
-                        return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                        return addCorsHeaders(errorResponse, request, env);
                     }
                     updateData.role = role;
                 }
@@ -510,10 +473,10 @@ exports.dashboardRoutes = [
                 }
                 if (Object.keys(updateData).length === 0) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "No valid fields to update" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Update user
-                const updatedUser = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const updatedUser = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.update({
                         where: { id: userId },
                         data: updateData,
@@ -525,7 +488,7 @@ exports.dashboardRoutes = [
                             createdAt: true,
                         },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 const response = securityHeaders.createSecureResponse(JSON.stringify({
                     id: updatedUser.id,
                     email: updatedUser.email,
@@ -533,63 +496,63 @@ exports.dashboardRoutes = [
                     status: updatedUser.suspended ? "suspended" : "active",
                     updatedAt: new Date().toISOString(),
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error updating user:", error);
                 if (error.code === "P2025" ||
                     error.message?.includes("Record to update not found")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "User not found" }), { status: 404, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to update user" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Update user (role, status, etc.)",
     },
     {
         path: /^\/api\/dashboard\/users\/(.+)$/,
         method: "DELETE",
         handler: async (request, env, { pathname }) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Extract user ID from path
                 const userIdMatch = pathname.match(/^\/api\/dashboard\/users\/(.+)$/);
                 if (!userIdMatch) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Invalid user ID" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const userId = userIdMatch[1];
                 // Prevent self-deletion
                 if (userId === session.userId) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Cannot delete your own account" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Delete user (soft delete by setting deletion flags)
-                await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.update({
                         where: { id: userId },
                         data: {
@@ -597,25 +560,25 @@ exports.dashboardRoutes = [
                             deletionScheduledAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days
                         },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 const response = securityHeaders.createSecureResponse(JSON.stringify({
                     success: true,
                     message: "User deleted successfully",
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error deleting user:", error);
                 if (error.code === "P2025" ||
                     error.message?.includes("Record to update not found")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "User not found" }), { status: 404, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to delete user" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Delete user account",
     },
     // Content Moderation
@@ -623,28 +586,28 @@ exports.dashboardRoutes = [
         path: "/api/dashboard/moderation/posts",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Parse query parameters
                 const url = new URL(request.url);
@@ -657,49 +620,49 @@ exports.dashboardRoutes = [
                     posts: [],
                     total: 0,
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error listing moderation posts:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to list moderation posts" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "List posts requiring moderation",
     },
     {
         path: /^\/api\/dashboard\/moderation\/posts\/(.+)\/action$/,
         method: "POST",
         handler: async (request, env, { pathname }) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be INTERNAL
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "INTERNAL" && user.role !== "SUPER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Internal access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Extract post ID from path
                 const postIdMatch = pathname.match(/^\/api\/dashboard\/moderation\/posts\/(.+)\/action$/);
                 if (!postIdMatch) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Invalid post ID" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const postId = postIdMatch[1];
                 // Parse request body
@@ -710,7 +673,7 @@ exports.dashboardRoutes = [
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({
                         error: 'Invalid action. Must be "approve", "reject", or "delete"',
                     }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // TODO: Implement actual moderation actions
                 // For now, return success as placeholder
@@ -718,15 +681,15 @@ exports.dashboardRoutes = [
                     success: true,
                     message: `Post ${action}d successfully`,
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error moderating post:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to moderate post" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Moderate a post (approve/reject/delete)",
     },
     // Partner Dashboard APIs
@@ -734,28 +697,28 @@ exports.dashboardRoutes = [
         path: "/api/dashboard/b2b/usage/requests",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be PARTNER
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true /* T3 will replace partnerId with tenant context */ },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "B2B_PARTNER" && user.role !== "PARTNER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Partner access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Parse query parameters
                 const url = new URL(request.url);
@@ -783,43 +746,43 @@ exports.dashboardRoutes = [
                         byEndpoint: [],
                     },
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting partner usage:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get partner usage" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get API request volume for partner",
     },
     {
         path: "/api/dashboard/b2b/usage/rate-limits",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be PARTNER
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "B2B_PARTNER" && user.role !== "PARTNER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Partner access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // TODO: Implement actual rate limit tracking
                 // Placeholder response
@@ -831,43 +794,43 @@ exports.dashboardRoutes = [
                     window: "hourly",
                     history: [],
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting rate limits:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get rate limits" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get rate limit status for partner",
     },
     {
         path: "/api/dashboard/b2b/performance",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be PARTNER
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user ||
                     (user.role !== "B2B_PARTNER" && user.role !== "PARTNER_ADMIN")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Partner access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Parse query parameters
                 const url = new URL(request.url);
@@ -886,15 +849,15 @@ exports.dashboardRoutes = [
                         errorRate: [],
                     },
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting partner performance:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get partner performance" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get API performance metrics for partner",
     },
     // Scaling Health
@@ -902,31 +865,31 @@ exports.dashboardRoutes = [
         path: "/api/dashboard/scaling-health",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user || user.role !== "SUPER_ADMIN") {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({
                         error: "Forbidden: Super-admin access required",
                     }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Get user counts from database
-                const counts = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const counts = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
                     const [totalUsers, recentUsers] = await Promise.all([
                         db.user.count(),
@@ -935,19 +898,19 @@ exports.dashboardRoutes = [
                         }),
                     ]);
                     return { totalUsers, recentActiveUsers: recentUsers };
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
-                const { evaluateScalingHealth } = await Promise.resolve().then(() => __importStar(require("../scaling-health")));
+                }, QueryTimeoutPresets.STANDARD);
+                const { evaluateScalingHealth } = await import("../scaling-health.js");
                 const result = await evaluateScalingHealth(env, counts.totalUsers, counts.recentActiveUsers);
                 const response = securityHeaders.createSecureResponse(JSON.stringify(result), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting scaling health:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get scaling health" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get scaling health indicators (SUPER_ADMIN only)",
     },
     // Abuse Metrics
@@ -955,43 +918,43 @@ exports.dashboardRoutes = [
         path: "/api/dashboard/abuse-metrics",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user || user.role !== "SUPER_ADMIN") {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({
                         error: "Forbidden: Super-admin access required",
                     }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const url = new URL(request.url);
                 const timeRange = url.searchParams.get("timeRange") || "24h";
-                const { evaluateAbuseMetrics } = await Promise.resolve().then(() => __importStar(require("../abuse-metrics")));
+                const { evaluateAbuseMetrics } = await import("../abuse-metrics.js");
                 const result = await evaluateAbuseMetrics(env, timeRange);
                 const response = securityHeaders.createSecureResponse(JSON.stringify(result), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Dashboard] Error getting abuse metrics:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to get abuse metrics" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Get abuse metrics and WAF effectiveness (SUPER_ADMIN only)",
     },
     // Role Management APIs
@@ -999,30 +962,30 @@ exports.dashboardRoutes = [
         path: "/api/admin/roles",
         method: "GET",
         handler: async (request, env) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be SUPER_ADMIN
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user || user.role !== "SUPER_ADMIN") {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Super-admin access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Get role metadata
-                const db = (0, db_1.createPrisma)(env);
+                const db = createPrisma(env);
                 const roles = await db.roleMetadata.findMany({
                     where: { isActive: true },
                     orderBy: { role: "asc" },
@@ -1036,48 +999,48 @@ exports.dashboardRoutes = [
                         permissions: r.permissions || [],
                     })),
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Admin] Error listing roles:", error);
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to list roles" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "List all available roles",
     },
     {
         path: /^\/api\/admin\/users\/(.+)\/role$/,
         method: "PATCH",
         handler: async (request, env, { pathname }) => {
-            const sessionManager = new session_manager_1.SessionManager();
-            const securityHeaders = new security_headers_1.SecurityHeaders(env);
-            const logger = logger_1.Logger.getInstance(env);
-            const session = await sessionManager.getSession(request, secret_resolver_1.Secrets.getSessionSecret(env), env);
+            const sessionManager = new SessionManager();
+            const securityHeaders = new SecurityHeaders(env);
+            const logger = getLogger();
+            const session = await sessionManager.getSession(request, env.SESSION_SECRET, env);
             if (!session) {
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
             try {
                 // Check user role - must be SUPER_ADMIN
-                const region = (0, region_detection_1.detectRegionSync)(request, env);
-                const dbManager = database_connection_manager_1.sharedDatabaseConnectionManager;
-                const user = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const region = detectRegionSync(request, env);
+                const dbManager = sharedDatabaseConnectionManager;
+                const user = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.findUnique({
                         where: { id: session.userId },
                         select: { role: true },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 if (!user || user.role !== "SUPER_ADMIN") {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Forbidden: Super-admin access required" }), { status: 403, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Extract user ID from path
                 const userIdMatch = pathname.match(/^\/api\/admin\/users\/(.+)\/role$/);
                 if (!userIdMatch) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Invalid user ID" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const userId = userIdMatch[1];
                 // Parse request body
@@ -1085,7 +1048,7 @@ exports.dashboardRoutes = [
                 const { role } = body;
                 if (!role) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Role is required" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Validate role
                 const validRoles = [
@@ -1098,10 +1061,10 @@ exports.dashboardRoutes = [
                 ];
                 if (!validRoles.includes(role)) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Invalid role" }), { status: 400, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 // Update user role
-                const updatedUser = await (0, db_query_helper_1.withQueryTimeoutAndRetry)(dbManager, region, env, async (db) => {
+                const updatedUser = await withQueryTimeoutAndRetry(dbManager, region, env, async (db) => {
                     return db.user.update({
                         where: { id: userId },
                         data: { role: role },
@@ -1112,27 +1075,27 @@ exports.dashboardRoutes = [
                             createdAt: true,
                         },
                     });
-                }, db_query_helper_1.QueryTimeoutPresets.STANDARD);
+                }, QueryTimeoutPresets.STANDARD);
                 const response = securityHeaders.createSecureResponse(JSON.stringify({
                     id: updatedUser.id,
                     email: updatedUser.email,
                     role: updatedUser.role,
                     updatedAt: new Date().toISOString(),
                 }), { status: 200, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(response, request, env);
+                return addCorsHeaders(response, request, env);
             }
             catch (error) {
                 logger.error("[Admin] Error changing user role:", error);
                 if (error.code === "P2025" ||
                     error.message?.includes("Record to update not found")) {
                     const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "User not found" }), { status: 404, headers: { "content-type": "application/json" } });
-                    return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                    return addCorsHeaders(errorResponse, request, env);
                 }
                 const errorResponse = securityHeaders.createSecureResponse(JSON.stringify({ error: "Failed to change user role" }), { status: 500, headers: { "content-type": "application/json" } });
-                return (0, worker_1.addCorsHeaders)(errorResponse, request, env);
+                return addCorsHeaders(errorResponse, request, env);
             }
         },
-        middleware: [(0, middleware_1.corsMiddleware)(), (0, middleware_1.csrfMiddleware)()],
+        middleware: [corsMiddleware(), csrfMiddleware()],
         description: "Change user role",
     },
 ];