@withwiz/toolkit 0.5.1 → 0.6.0

package/dist/chunk-JQFQT4S2.js

@@ -0,0 +1,55 @@
+import {
+  JWTService
+} from "./chunk-3GAY2T2A.js";
+import {
+  AuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/services/token-refresh.service.ts
+var TokenRefreshService = class {
+  constructor(config) {
+    var _a, _b, _c;
+    this.userRepo = config.userRepository;
+    this.jwtService = new JWTService({
+      secret: config.jwtSecret,
+      accessTokenExpiry: (_a = config.accessTokenExpiry) != null ? _a : "7d",
+      refreshTokenExpiry: (_b = config.refreshTokenExpiry) != null ? _b : "30d",
+      algorithm: "HS256"
+    }, config.logger);
+    this.isTokenBlacklisted = config.isTokenBlacklisted;
+    this.logger = (_c = config.logger) != null ? _c : { debug() {
+    }, info() {
+    }, warn() {
+    }, error() {
+    } };
+  }
+  async refresh(refreshToken) {
+    var _a, _b;
+    if (this.isTokenBlacklisted) {
+      const blacklisted = await this.isTokenBlacklisted(refreshToken);
+      if (blacklisted) {
+        throw new AuthError("Token has been revoked", "TOKEN_REVOKED", 401);
+      }
+    }
+    const { userId } = await this.jwtService.verifyRefreshToken(refreshToken);
+    const user = await this.userRepo.findById(userId);
+    if (!user) {
+      throw new AuthError("User not found", "USER_NOT_FOUND", 401);
+    }
+    if (user.isActive === false) {
+      throw new AuthError("Account is disabled", "ACCOUNT_DISABLED", 403);
+    }
+    const accessToken = await this.jwtService.createAccessToken({
+      id: user.id,
+      userId: user.id,
+      email: user.email,
+      role: (_a = user.role) != null ? _a : "USER",
+      emailVerified: user.emailVerified
+    });
+    return { accessToken, user: { id: user.id, email: user.email, role: (_b = user.role) != null ? _b : "USER" } };
+  }
+};
+
+export {
+  TokenRefreshService
+};

package/dist/{chunk-FPESPW6P.js → chunk-KF3O2DAV.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-GQVBWZLH.js";
+} from "./chunk-TEXVRHPF.js";
 import {
   __spreadValues
 } from "./chunk-ORMEWXMH.js";

package/dist/chunk-KY7JZ54O.js

@@ -0,0 +1,62 @@
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/auth/email/sender.ts
+var SmtpEmailSender = class {
+  constructor(config) {
+    this.config = config;
+    this.templates = __spreadValues(__spreadValues({}, getDefaultTemplates()), config.templates);
+  }
+  async sendVerificationEmail(email, token) {
+    const { subject, html } = this.templates.verification({ email, token, baseUrl: this.config.baseUrl });
+    await this.send(email, subject, html);
+  }
+  async sendPasswordResetEmail(email, token) {
+    const { subject, html } = this.templates.passwordReset({ email, token, baseUrl: this.config.baseUrl });
+    await this.send(email, subject, html);
+  }
+  async sendMagicLinkEmail(email, token) {
+    const { subject, html } = this.templates.magicLink({ email, token, baseUrl: this.config.baseUrl });
+    await this.send(email, subject, html);
+  }
+  async sendWelcomeEmail(email, name) {
+    const { subject, html } = this.templates.welcome({ email, name });
+    await this.send(email, subject, html);
+  }
+  async send(to, subject, html) {
+    var _a;
+    const nodemailer = await import("nodemailer");
+    const transport = nodemailer.createTransport({
+      host: this.config.host,
+      port: this.config.port,
+      secure: (_a = this.config.secure) != null ? _a : this.config.port === 465,
+      auth: { user: this.config.user, pass: this.config.pass }
+    });
+    await transport.sendMail({ from: this.config.from, to, subject, html });
+  }
+};
+function getDefaultTemplates() {
+  return {
+    verification: ({ email, token, baseUrl }) => ({
+      subject: "Verify your email",
+      html: `<p>Click the link to verify your email:</p><a href="${baseUrl}/verify-email?email=${encodeURIComponent(email)}&token=${token}">Verify Email</a>`
+    }),
+    passwordReset: ({ email, token, baseUrl }) => ({
+      subject: "Reset your password",
+      html: `<p>Click the link to reset your password:</p><a href="${baseUrl}/reset-password?email=${encodeURIComponent(email)}&token=${token}">Reset Password</a>`
+    }),
+    magicLink: ({ email, token, baseUrl }) => ({
+      subject: "Your login link",
+      html: `<p>Click the link to sign in:</p><a href="${baseUrl}/auth/magic-link?email=${encodeURIComponent(email)}&token=${token}">Sign In</a>`
+    }),
+    welcome: ({ name }) => ({
+      subject: "Welcome!",
+      html: `<p>Hi ${name}, welcome to our platform!</p>`
+    })
+  };
+}
+
+export {
+  SmtpEmailSender
+};

package/dist/{chunk-2F6KNGOD.js → chunk-L5WLPC2T.js}

@@ -9,7 +9,7 @@ import {
   logApiRequest,
   logApiResponse,
   logger
-} from "./chunk-GQVBWZLH.js";
+} from "./chunk-TEXVRHPF.js";
 
 // src/utils/error-processor.ts
 import { NextResponse } from "next/server";

package/dist/{chunk-ZBXSEQ6W.js → chunk-LFKPXF5E.js}

@@ -4,15 +4,15 @@ import {
 import {
   ERROR_CODES
 } from "./chunk-SNTLJ646.js";
-import {
-  getAuthConfig
-} from "./chunk-OZE5KUS3.js";
 import {
   JWTManager
 } from "./chunk-3GAY2T2A.js";
+import {
+  getAuthConfig
+} from "./chunk-A2XAOU55.js";
 import {
   logger
-} from "./chunk-GQVBWZLH.js";
+} from "./chunk-TEXVRHPF.js";
 
 // src/middleware/auth.ts
 function setAccessTokenBlacklistChecker(checker) {

package/dist/{chunk-L6AU74EI.js → chunk-MDTID4D2.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-AIH3F7JV.js";
 import {
   logger
-} from "./chunk-GQVBWZLH.js";
+} from "./chunk-TEXVRHPF.js";
 import {
   __spreadProps,
   __spreadValues

package/dist/{chunk-KHYY4KCV.js → chunk-MEFZZE4M.js}

@@ -1,12 +1,12 @@
 import {
   formatLabel
-} from "./chunk-NY5QXT33.js";
-import {
-  Input
-} from "./chunk-RJUVBBZG.js";
+} from "./chunk-I6Q3WUDT.js";
 import {
   Button
 } from "./chunk-L25BNU3E.js";
+import {
+  Input
+} from "./chunk-RJUVBBZG.js";
 
 // src/components/ui/data-table/DataTableSearch.tsx
 import { isValidElement } from "react";

package/dist/chunk-MGQV723O.js

@@ -0,0 +1,104 @@
+import {
+  JWTService
+} from "./chunk-3GAY2T2A.js";
+import {
+  setTokenCookies
+} from "./chunk-G2Q4TI3Q.js";
+import {
+  AuthError
+} from "./chunk-AIH3F7JV.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/auth/handlers/login.handler.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { compare } from "bcryptjs";
+var loginSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(1)
+});
+function createLoginHandler(options) {
+  var _a, _b;
+  const { dependencies, jwt, hooks, features, cookie } = options;
+  const jwtService = new JWTService({
+    secret: jwt.secret,
+    accessTokenExpiry: (_a = jwt.accessTokenExpiry) != null ? _a : "7d",
+    refreshTokenExpiry: (_b = jwt.refreshTokenExpiry) != null ? _b : "30d",
+    algorithm: "HS256"
+  });
+  return async (request) => {
+    var _a2;
+    try {
+      const body = await request.json();
+      const parsed = loginSchema.safeParse(body);
+      if (!parsed.success) {
+        return NextResponse.json({ success: false, error: "Invalid input" }, { status: 400 });
+      }
+      const { email, password } = parsed.data;
+      if (hooks == null ? void 0 : hooks.allowEmail) {
+        const allowed = await hooks.allowEmail(email);
+        if (!allowed) return NextResponse.json({ success: false, error: "Email not allowed" }, { status: 403 });
+      }
+      if (hooks == null ? void 0 : hooks.onBeforeLogin) {
+        const hookResult = await hooks.onBeforeLogin(email, request);
+        if (hookResult instanceof Response) return hookResult;
+      }
+      const user = await dependencies.userRepository.findByEmail(email);
+      if (!user) {
+        return NextResponse.json({ success: false, error: "Invalid credentials" }, { status: 401 });
+      }
+      if (user.isActive === false) {
+        return NextResponse.json({ success: false, error: "Account disabled" }, { status: 403 });
+      }
+      const userRecord = user;
+      if (!userRecord.password) {
+        return NextResponse.json({ success: false, error: "Invalid credentials" }, { status: 401 });
+      }
+      const isValid = await compare(password, userRecord.password);
+      if (!isValid) {
+        return NextResponse.json({ success: false, error: "Invalid credentials" }, { status: 401 });
+      }
+      if ((features == null ? void 0 : features.emailVerificationRequired) && !user.emailVerified) {
+        return NextResponse.json(
+          { success: false, error: "Email not verified", code: "EMAIL_NOT_VERIFIED" },
+          { status: 403 }
+        );
+      }
+      const tokens = await jwtService.createTokenPair({
+        id: user.id,
+        email: user.email,
+        role: (_a2 = user.role) != null ? _a2 : "USER",
+        emailVerified: user.emailVerified
+      });
+      await dependencies.userRepository.updateLastLoginAt(user.id);
+      if (hooks == null ? void 0 : hooks.onAfterLogin) await hooks.onAfterLogin(user, request);
+      let userResponse = {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role,
+        emailVerified: user.emailVerified
+      };
+      if (hooks == null ? void 0 : hooks.extendUserResponse) {
+        userResponse = __spreadValues(__spreadValues({}, userResponse), await hooks.extendUserResponse(user));
+      }
+      const response = NextResponse.json({ success: true, user: userResponse, tokens });
+      setTokenCookies(response, tokens, { secure: cookie == null ? void 0 : cookie.secure });
+      return response;
+    } catch (error) {
+      if (error instanceof AuthError) {
+        return NextResponse.json(
+          { success: false, error: error.message, code: error.code },
+          { status: error.statusCode }
+        );
+      }
+      return NextResponse.json({ success: false, error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+
+export {
+  createLoginHandler
+};

package/dist/chunk-N6TMHITU.js

@@ -0,0 +1,49 @@
+import {
+  TokenGenerator
+} from "./chunk-GDWEDUHO.js";
+import {
+  AuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/services/email-verification.service.ts
+var EmailVerificationService = class {
+  constructor(config) {
+    var _a, _b;
+    this.userRepo = config.userRepository;
+    this.tokenRepo = config.emailTokenRepository;
+    this.emailSender = config.emailSender;
+    this.tokenExpiryHours = (_a = config.tokenExpiryHours) != null ? _a : 24;
+    this.logger = (_b = config.logger) != null ? _b : { debug() {
+    }, info() {
+    }, warn() {
+    }, error() {
+    } };
+  }
+  async verify(email, token) {
+    const tokenRecord = await this.tokenRepo.findByEmailAndToken(email, token, "EMAIL_VERIFICATION" /* EMAIL_VERIFICATION */);
+    if (!tokenRecord || tokenRecord.expires < /* @__PURE__ */ new Date()) {
+      throw new AuthError("Invalid or expired verification token", "TOKEN_INVALID", 400);
+    }
+    await this.userRepo.verifyEmail(email);
+    await this.tokenRepo.delete(email, token, "EMAIL_VERIFICATION" /* EMAIL_VERIFICATION */);
+    this.logger.info("Email verified", { email });
+  }
+  async resend(email) {
+    const user = await this.userRepo.findByEmail(email);
+    if (!user) {
+      throw new AuthError("User not found", "USER_NOT_FOUND", 404);
+    }
+    if (user.emailVerified) {
+      throw new AuthError("Email already verified", "EMAIL_ALREADY_VERIFIED", 400);
+    }
+    const token = TokenGenerator.generate();
+    const expires = new Date(Date.now() + this.tokenExpiryHours * 60 * 60 * 1e3);
+    await this.tokenRepo.create(email, token, "EMAIL_VERIFICATION" /* EMAIL_VERIFICATION */, expires);
+    await this.emailSender.sendVerificationEmail(email, token);
+    this.logger.info("Verification email resent", { email });
+  }
+};
+
+export {
+  EmailVerificationService
+};

package/dist/{chunk-NQQU6UFE.js → chunk-O35V6RIF.js}

@@ -3,14 +3,14 @@ import {
   isRedisGloballyDisabled,
   notifyRedisError,
   resetRedisGlobalState
-} from "./chunk-X5RMDLLM.js";
+} from "./chunk-IHUQRVPV.js";
 import {
   logger
-} from "./chunk-GQVBWZLH.js";
+} from "./chunk-TEXVRHPF.js";
 import {
   getENV,
   isCacheEnabled
-} from "./chunk-BJLLMVWW.js";
+} from "./chunk-DBHISLC6.js";
 import {
   __spreadValues
 } from "./chunk-ORMEWXMH.js";

package/dist/{chunk-4HBAPPB2.js → chunk-OCI7QCLM.js}

@@ -3,10 +3,10 @@ import {
   formatBytesPerSec,
   runCommand,
   runMacCommand
-} from "./chunk-S5UCZ2T3.js";
+} from "./chunk-X6MGVFT3.js";
 import {
   logger
-} from "./chunk-GQVBWZLH.js";
+} from "./chunk-TEXVRHPF.js";
 
 // src/system/network.ts
 async function getNetworkInfo() {

package/dist/{chunk-GFAD4UAT.js → chunk-ON7HZ3PW.js}

@@ -1,7 +1,7 @@
 import {
   cache,
   geoCache
-} from "./chunk-GGSFZP6T.js";
+} from "./chunk-7JKZBEVB.js";
 
 // src/cache/cache-invalidation.ts
 var invalidateCache = {

package/dist/{chunk-O3UR234Y.js → chunk-PAF5OGDU.js}

@@ -3,27 +3,27 @@ import {
 } from "./chunk-62Q7DN5G.js";
 import {
   MiddlewareChain
-} from "./chunk-FPESPW6P.js";
+} from "./chunk-KF3O2DAV.js";
 import {
   rateLimitMiddleware
-} from "./chunk-AQJAY5FA.js";
+} from "./chunk-WJSMXUZB.js";
 import {
   responseLoggerMiddleware
-} from "./chunk-OIRAH57Y.js";
+} from "./chunk-CKK55QFQ.js";
 import {
   securityMiddleware
-} from "./chunk-WMQE2YK7.js";
+} from "./chunk-4BGAE7NU.js";
 import {
   adminMiddleware,
   authMiddleware,
   optionalAuthMiddleware
-} from "./chunk-ZBXSEQ6W.js";
+} from "./chunk-LFKPXF5E.js";
 import {
   corsMiddleware
-} from "./chunk-KGHWGLED.js";
+} from "./chunk-7KZRPDQD.js";
 import {
   errorHandlerMiddleware
-} from "./chunk-3YUKCYHI.js";
+} from "./chunk-WRWWB2NU.js";
 
 // src/middleware/wrappers.ts
 function withPublicApi(handler) {

package/dist/{chunk-3J7FDOCU.js → chunk-PYVYYO4X.js}

@@ -1,18 +1,18 @@
 import {
   getPlatform
-} from "./chunk-S5UCZ2T3.js";
+} from "./chunk-X6MGVFT3.js";
 import {
   getGeolocationConfig
 } from "./chunk-3CBGGMIY.js";
 import {
   getAuthConfig
-} from "./chunk-OZE5KUS3.js";
-import {
-  getResolvedCacheConfig
-} from "./chunk-UCIUAZQT.js";
+} from "./chunk-A2XAOU55.js";
 import {
   getCommonConfig
 } from "./chunk-SFPMFVSD.js";
+import {
+  getResolvedCacheConfig
+} from "./chunk-UCIUAZQT.js";
 
 // src/system/environment.ts
 import os from "os";

package/dist/{chunk-CRWMULHR.js → chunk-Q6KXN7HL.js}

@@ -1,9 +1,9 @@
 import {
   getCacheConfig
-} from "./chunk-7LJWRKDT.js";
+} from "./chunk-BEV7PQM3.js";
 import {
   getENV
-} from "./chunk-BJLLMVWW.js";
+} from "./chunk-DBHISLC6.js";
 
 // src/cache/noop-cache-manager.ts
 var NoopCacheManager = class {

package/dist/chunk-Q7VFOUFI.js

@@ -0,0 +1,68 @@
+import {
+  RegisterService
+} from "./chunk-ETMTDHK2.js";
+import {
+  AuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/handlers/register.handler.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+var registerSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  name: z.string().min(1).optional()
+});
+function createRegisterHandler(options) {
+  var _a;
+  const { dependencies, hooks, features } = options;
+  const registerService = new RegisterService({
+    userRepository: dependencies.userRepository,
+    emailTokenRepository: dependencies.emailTokenRepository,
+    emailSender: dependencies.emailSender,
+    emailVerificationRequired: (_a = features == null ? void 0 : features.emailVerificationRequired) != null ? _a : true,
+    logger: dependencies.logger
+  });
+  return async (request) => {
+    try {
+      const body = await request.json();
+      const parsed = registerSchema.safeParse(body);
+      if (!parsed.success) {
+        return NextResponse.json(
+          { success: false, error: "Invalid input", details: parsed.error.flatten() },
+          { status: 400 }
+        );
+      }
+      if (hooks == null ? void 0 : hooks.allowEmail) {
+        const allowed = await hooks.allowEmail(parsed.data.email);
+        if (!allowed) return NextResponse.json({ success: false, error: "Email not allowed" }, { status: 403 });
+      }
+      if (hooks == null ? void 0 : hooks.onBeforeRegister) {
+        const hookResult = await hooks.onBeforeRegister({ email: parsed.data.email, name: parsed.data.name });
+        if (hookResult instanceof Response) return hookResult;
+      }
+      const result = await registerService.register(parsed.data);
+      if (hooks == null ? void 0 : hooks.onAfterRegister) await hooks.onAfterRegister(result.user);
+      return NextResponse.json(
+        {
+          success: true,
+          user: { id: result.user.id, email: result.user.email, name: result.user.name },
+          verificationSent: result.verificationSent
+        },
+        { status: 201 }
+      );
+    } catch (error) {
+      if (error instanceof AuthError) {
+        return NextResponse.json(
+          { success: false, error: error.message, code: error.code },
+          { status: error.statusCode }
+        );
+      }
+      return NextResponse.json({ success: false, error: "Internal server error" }, { status: 500 });
+    }
+  };
+}
+
+export {
+  createRegisterHandler
+};

package/dist/chunk-QYXI45KH.js

@@ -0,0 +1,62 @@
+import {
+  EmailVerificationService
+} from "./chunk-N6TMHITU.js";
+import {
+  AuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/handlers/verify-email.handler.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+var schema = z.object({
+  email: z.string().email(),
+  token: z.string().min(1)
+});
+function createVerifyEmailHandler(options) {
+  const { dependencies } = options;
+  return async (request) => {
+    var _a, _b;
+    try {
+      let email, token;
+      if (request.method === "GET") {
+        const url = new URL(request.url);
+        email = (_a = url.searchParams.get("email")) != null ? _a : "";
+        token = (_b = url.searchParams.get("token")) != null ? _b : "";
+      } else {
+        const body = await request.json();
+        const parsed = schema.safeParse(body);
+        if (!parsed.success) {
+          return NextResponse.json({ success: false, error: "Invalid input" }, { status: 400 });
+        }
+        email = parsed.data.email;
+        token = parsed.data.token;
+      }
+      if (!email || !token) {
+        return NextResponse.json({ success: false, error: "Missing email or token" }, { status: 400 });
+      }
+      if (!dependencies.emailSender) {
+        return NextResponse.json({ success: false, error: "Email service not configured" }, { status: 500 });
+      }
+      const service = new EmailVerificationService({
+        userRepository: dependencies.userRepository,
+        emailTokenRepository: dependencies.emailTokenRepository,
+        emailSender: dependencies.emailSender,
+        logger: dependencies.logger
+      });
+      await service.verify(email, token);
+      return NextResponse.json({ success: true });
+    } catch (error) {
+      if (error instanceof AuthError) {
+        return NextResponse.json(
+          { success: false, error: error.message },
+          { status: error.statusCode }
+        );
+      }
+      return NextResponse.json({ success: false, error: "Verification failed" }, { status: 500 });
+    }
+  };
+}
+
+export {
+  createVerifyEmailHandler
+};

package/dist/chunk-S7OQWKUJ.js

@@ -0,0 +1,83 @@
+import {
+  OAuthCallbackService
+} from "./chunk-6B7VU6RZ.js";
+import {
+  OAuthManager
+} from "./chunk-HZLJYEOO.js";
+import {
+  setTokenCookies
+} from "./chunk-G2Q4TI3Q.js";
+import {
+  AuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/handlers/oauth-callback.handler.ts
+import { NextResponse } from "next/server";
+function createOAuthCallbackHandler(options) {
+  const { dependencies, jwt, oauth, hooks, cookie, urls } = options;
+  const callbackService = new OAuthCallbackService({
+    userRepository: dependencies.userRepository,
+    oauthAccountRepository: dependencies.oauthAccountRepository,
+    jwtSecret: jwt.secret,
+    accessTokenExpiry: jwt.accessTokenExpiry,
+    refreshTokenExpiry: jwt.refreshTokenExpiry,
+    logger: dependencies.logger
+  });
+  return async (request) => {
+    var _a, _b, _c, _d;
+    try {
+      const url = new URL(request.url);
+      const code = url.searchParams.get("code");
+      const provider = (_a = url.searchParams.get("provider")) != null ? _a : url.pathname.split("/").pop();
+      if (!code || !provider || !(oauth == null ? void 0 : oauth[provider])) {
+        return NextResponse.json({ success: false, error: "Invalid callback" }, { status: 400 });
+      }
+      const providers = {};
+      for (const [name, config] of Object.entries(oauth)) {
+        providers[name] = config;
+      }
+      const noopLogger = { debug() {
+      }, info() {
+      }, warn() {
+      }, error() {
+      } };
+      const manager = new OAuthManager({ providers }, (_b = dependencies.logger) != null ? _b : noopLogger);
+      const accessToken = await manager.exchangeCodeForToken(provider, code);
+      const userInfo = await manager.getUserInfo(provider, accessToken);
+      if (hooks == null ? void 0 : hooks.allowEmail) {
+        const allowed = await hooks.allowEmail(userInfo.email);
+        if (!allowed) return NextResponse.json({ success: false, error: "Email not allowed" }, { status: 403 });
+      }
+      const result = await callbackService.handleCallback({
+        provider,
+        providerAccountId: userInfo.id,
+        email: userInfo.email,
+        name: userInfo.name,
+        image: userInfo.image,
+        accessToken
+      });
+      if (hooks == null ? void 0 : hooks.onAfterOAuth) await hooks.onAfterOAuth(result.user, provider, result.isNewUser);
+      if (result.isNewUser && (hooks == null ? void 0 : hooks.onOAuthFirstLogin)) {
+        const redirect = await hooks.onOAuthFirstLogin(result.user, provider);
+        if (redirect) {
+          const response2 = NextResponse.redirect(redirect);
+          setTokenCookies(response2, result.tokens, { secure: cookie == null ? void 0 : cookie.secure });
+          return response2;
+        }
+      }
+      const redirectUrl = (_d = (_c = urls.afterOAuth) != null ? _c : urls.afterLogin) != null ? _d : "/";
+      const response = NextResponse.redirect(new URL(redirectUrl, urls.baseUrl));
+      setTokenCookies(response, result.tokens, { secure: cookie == null ? void 0 : cookie.secure });
+      return response;
+    } catch (error) {
+      if (error instanceof AuthError) {
+        return NextResponse.json({ success: false, error: error.message }, { status: error.statusCode });
+      }
+      return NextResponse.json({ success: false, error: "OAuth callback failed" }, { status: 500 });
+    }
+  };
+}
+
+export {
+  createOAuthCallbackHandler
+};