@withwiz/toolkit 0.5.2 → 0.6.1

package/dist/chunk-FI46LV42.js

@@ -0,0 +1,56 @@
+import {
+  TokenRefreshService
+} from "./chunk-JQFQT4S2.js";
+import {
+  setTokenCookies
+} from "./chunk-G2Q4TI3Q.js";
+import {
+  AuthError
+} from "./chunk-AIH3F7JV.js";
+
+// src/auth/handlers/refresh.handler.ts
+import { NextResponse } from "next/server";
+function createRefreshHandler(options) {
+  const { dependencies, jwt, hooks, cookie } = options;
+  const refreshService = new TokenRefreshService({
+    userRepository: dependencies.userRepository,
+    jwtSecret: jwt.secret,
+    accessTokenExpiry: jwt.accessTokenExpiry,
+    refreshTokenExpiry: jwt.refreshTokenExpiry,
+    isTokenBlacklisted: hooks == null ? void 0 : hooks.isTokenBlacklisted,
+    logger: dependencies.logger
+  });
+  return async (request) => {
+    var _a;
+    try {
+      const refreshToken = (_a = request.cookies.get("refresh_token")) == null ? void 0 : _a.value;
+      if (!refreshToken) {
+        return NextResponse.json({ success: false, error: "No refresh token" }, { status: 401 });
+      }
+      if (hooks == null ? void 0 : hooks.onBeforeTokenRefresh) {
+        const hookResult = await hooks.onBeforeTokenRefresh(refreshToken);
+        if (hookResult instanceof Response) return hookResult;
+      }
+      const result = await refreshService.refresh(refreshToken);
+      const response = NextResponse.json({
+        success: true,
+        accessToken: result.accessToken,
+        user: result.user
+      });
+      setTokenCookies(response, { accessToken: result.accessToken, refreshToken }, { 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: "Token refresh failed" }, { status: 401 });
+    }
+  };
+}
+
+export {
+  createRefreshHandler
+};

package/dist/{chunk-LX2EYD74.js → chunk-FNECYXI4.js}

@@ -1,21 +1,21 @@
-import {
-  DataTableBody
-} from "./chunk-7IY3RQQL.js";
-import {
-  DataTableBulkActions
-} from "./chunk-MAATEX2R.js";
 import {
   DataTableFilters
-} from "./chunk-SEZJN4TC.js";
+} from "./chunk-5UVEOCRU.js";
 import {
   DataTablePagination
-} from "./chunk-IPXPCBDO.js";
+} from "./chunk-WVDYHSHD.js";
 import {
   DataTableSearch
-} from "./chunk-KHYY4KCV.js";
+} from "./chunk-MEFZZE4M.js";
+import {
+  DataTableBody
+} from "./chunk-7IY3RQQL.js";
+import {
+  DataTableBulkActions
+} from "./chunk-CRMXLNLC.js";
 import {
   DEFAULT_LABELS
-} from "./chunk-NY5QXT33.js";
+} from "./chunk-I6Q3WUDT.js";
 import {
   Alert,
   AlertDescription

package/dist/chunk-FRY3TNJ6.js

@@ -0,0 +1,37 @@
+import {
+  PasswordResetService
+} from "./chunk-WC2IYFGC.js";
+
+// src/auth/handlers/forgot-password.handler.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+var schema = z.object({ email: z.string().email() });
+function createForgotPasswordHandler(options) {
+  const { dependencies } = options;
+  return async (request) => {
+    try {
+      const body = await request.json();
+      const parsed = schema.safeParse(body);
+      if (!parsed.success) {
+        return NextResponse.json({ success: false, error: "Invalid email" }, { status: 400 });
+      }
+      if (!dependencies.emailSender) {
+        return NextResponse.json({ success: false, error: "Email service not configured" }, { status: 500 });
+      }
+      const service = new PasswordResetService({
+        userRepository: dependencies.userRepository,
+        emailTokenRepository: dependencies.emailTokenRepository,
+        emailSender: dependencies.emailSender,
+        logger: dependencies.logger
+      });
+      await service.requestReset(parsed.data.email);
+      return NextResponse.json({ success: true });
+    } catch (e) {
+      return NextResponse.json({ success: true });
+    }
+  };
+}
+
+export {
+  createForgotPasswordHandler
+};

package/dist/{chunk-ZEIFD4OQ.js → chunk-G2Q4TI3Q.js}

@@ -1,6 +1,6 @@
 import {
   getAuthConfig
-} from "./chunk-OSNQ3TUX.js";
+} from "./chunk-A2XAOU55.js";
 import {
   __spreadValues
 } from "./chunk-ORMEWXMH.js";

package/dist/{chunk-LCKQOHXI.js → chunk-G5OMETUS.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-AHDPGRXS.js";
 import {
   getGeolocationConfig
-} from "./chunk-2VNDWG6P.js";
+} from "./chunk-3CBGGMIY.js";
 
 // src/geolocation/providers/maxmind-provider.ts
 var MaxMindProvider = class extends BaseGeoIPProvider {

package/dist/chunk-GTPUVHSV.js

@@ -0,0 +1,30 @@
+// src/config/registry.ts
+var MODULE_KEYS = {
+  common: "__withwiz_common_config",
+  auth: "__withwiz_auth_config",
+  logger: "__withwiz_logger_config",
+  cache: "__withwiz_cache_config",
+  storage: "__withwiz_storage_config",
+  geolocation: "__withwiz_geolocation_config",
+  cors: "__withwiz_cors_config"
+};
+var config = new Proxy({}, {
+  get(_target, prop) {
+    const globalKey = MODULE_KEYS[prop];
+    if (!globalKey) return void 0;
+    return globalThis[globalKey];
+  },
+  set() {
+    throw new TypeError("config is read-only");
+  }
+});
+function resetConfig() {
+  for (const globalKey of Object.values(MODULE_KEYS)) {
+    globalThis[globalKey] = void 0;
+  }
+}
+
+export {
+  config,
+  resetConfig
+};

package/dist/{chunk-GCR4PGRY.js → chunk-HHCDMWEF.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AHDPGRXS.js";
 import {
   getGeolocationConfig
-} from "./chunk-2VNDWG6P.js";
+} from "./chunk-3CBGGMIY.js";
 
 // src/geolocation/providers/ipgeolocation-provider.ts
 var IPGeolocationProvider = class extends BaseGeoIPProvider {

package/dist/{chunk-ENIKCCAV.js → chunk-IHUQRVPV.js}

@@ -1,13 +1,13 @@
 import {
   logger
-} from "./chunk-L6OEQBOM.js";
+} from "./chunk-TEXVRHPF.js";
 import {
   getCacheFallbackConfig,
   getConfig,
   getEnv,
   isCacheEnabled,
   validateRedisEnvironment
-} from "./chunk-5FSPXXNB.js";
+} from "./chunk-DBHISLC6.js";
 
 // src/cache/cache-redis.ts
 import { Redis } from "@upstash/redis";

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-5E66FUBP.js → chunk-KF3O2DAV.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-L6OEQBOM.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-33BG6FPO.js → chunk-L5WLPC2T.js}

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

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

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

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

@@ -7,12 +7,12 @@ import {
   formatErrorMessage,
   getHttpStatus
 } from "./chunk-SNTLJ646.js";
-import {
-  logger
-} from "./chunk-L6OEQBOM.js";
 import {
   AuthError
 } from "./chunk-AIH3F7JV.js";
+import {
+  logger
+} 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-BYHP4EH3.js → chunk-O35V6RIF.js}

@@ -3,14 +3,14 @@ import {
   isRedisGloballyDisabled,
   notifyRedisError,
   resetRedisGlobalState
-} from "./chunk-ENIKCCAV.js";
+} from "./chunk-IHUQRVPV.js";
 import {
   logger
-} from "./chunk-L6OEQBOM.js";
+} from "./chunk-TEXVRHPF.js";
 import {
   getENV,
   isCacheEnabled
-} from "./chunk-5FSPXXNB.js";
+} from "./chunk-DBHISLC6.js";
 import {
   __spreadValues
 } from "./chunk-ORMEWXMH.js";

package/dist/{chunk-2B4EKCV6.js → chunk-OCI7QCLM.js}

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

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

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

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

@@ -3,27 +3,27 @@ import {
 } from "./chunk-62Q7DN5G.js";
 import {
   MiddlewareChain
-} from "./chunk-5E66FUBP.js";
+} from "./chunk-KF3O2DAV.js";
 import {
   rateLimitMiddleware
-} from "./chunk-XIDMCDD3.js";
+} from "./chunk-WJSMXUZB.js";
 import {
   responseLoggerMiddleware
-} from "./chunk-ZRXE4WSP.js";
+} from "./chunk-CKK55QFQ.js";
 import {
   securityMiddleware
-} from "./chunk-PEFRPADW.js";
+} from "./chunk-4BGAE7NU.js";
 import {
   adminMiddleware,
   authMiddleware,
   optionalAuthMiddleware
-} from "./chunk-YGJJIC6S.js";
+} from "./chunk-LFKPXF5E.js";
 import {
   corsMiddleware
-} from "./chunk-3TD5OAQS.js";
+} from "./chunk-7KZRPDQD.js";
 import {
   errorHandlerMiddleware
-} from "./chunk-TCQ2DA6Y.js";
+} from "./chunk-WRWWB2NU.js";
 
 // src/middleware/wrappers.ts
 function withPublicApi(handler) {

package/dist/{chunk-S2O22ULX.js → chunk-PYVYYO4X.js}

@@ -1,18 +1,18 @@
 import {
   getPlatform
-} from "./chunk-4J4D27BV.js";
+} from "./chunk-X6MGVFT3.js";
 import {
   getGeolocationConfig
-} from "./chunk-2VNDWG6P.js";
+} from "./chunk-3CBGGMIY.js";
 import {
   getAuthConfig
-} from "./chunk-OSNQ3TUX.js";
-import {
-  getResolvedCacheConfig
-} from "./chunk-AN7GU7PF.js";
+} from "./chunk-A2XAOU55.js";
 import {
   getCommonConfig
-} from "./chunk-XICTHSUH.js";
+} from "./chunk-SFPMFVSD.js";
+import {
+  getResolvedCacheConfig
+} from "./chunk-UCIUAZQT.js";
 
 // src/system/environment.ts
 import os from "os";

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

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