@plyaz/auth 1.0.0 → 1.0.2

package/src/core/blacklist/token.blacklist.ts

@@ -12,7 +12,7 @@ export class TokenBlacklist {
   async add(tokenId: string, expiresAt: number): Promise<void> {
     const ttl = Math.max(0, expiresAt - Date.now());
     this.blacklistedTokens.set(tokenId, Date.now() + ttl);
-    
+
     // Auto-cleanup expired tokens
     globalThis.setTimeout(() => {
       this.blacklistedTokens.delete(tokenId);
@@ -26,26 +26,32 @@ export class TokenBlacklist {
   async isBlacklisted(tokenId: string): Promise<boolean> {
     const expiry = this.blacklistedTokens.get(tokenId);
     if (!expiry) return false;
-    
+
     if (expiry < Date.now()) {
       this.blacklistedTokens.delete(tokenId);
       return false;
     }
-    
+
     return true;
   }
 
-  async blacklistAllUserTokens(userId: string, issuedBefore: number): Promise<void> {
+  async blacklistAllUserTokens(
+    userId: string,
+    issuedBefore: number,
+  ): Promise<void> {
     // In production, this would use Redis with a user-specific key
     // For now, we'll use a simple approach
     const userKey = `user:${userId}:blacklist_before`;
     this.blacklistedTokens.set(userKey, issuedBefore);
   }
 
-  async isUserTokenBlacklisted(userId: string, tokenIssuedAt: number): Promise<boolean> {
+  async isUserTokenBlacklisted(
+    userId: string,
+    tokenIssuedAt: number,
+  ): Promise<boolean> {
     const userKey = `user:${userId}:blacklist_before`;
     const blacklistBefore = this.blacklistedTokens.get(userKey);
-    
+
     return blacklistBefore ? tokenIssuedAt < blacklistBefore : false;
   }
 
@@ -57,4 +63,4 @@ export class TokenBlacklist {
       }
     });
   }
-}
+}

package/src/core/index.ts

@@ -1,2 +1,2 @@
-export * from './jwt/jwt.manager';
-export * from './session/session.manager';
+export * from "./jwt/jwt.manager";
+export * from "./session/session.manager";

package/src/core/jwt/jwt.manager.ts

@@ -1,5 +1,5 @@
 import { sign, verify, type JwtPayload, type SignOptions } from "jsonwebtoken";
-import type { AuthTokens } from '@plyaz/types';
+import type { AuthTokens } from "@plyaz/types";
 import { NUMERIX } from "@plyaz/config";
 
 // Define the token payload interface
@@ -12,7 +12,6 @@ export interface TokenPayload extends JwtPayload {
 // Define the StringValue type to match what jsonwebtoken expects
 type StringValue = `${number}s` | `${number}m` | `${number}h` | `${number}d`;
 
-
 export class JwtManager {
   private config: {
     privateKey: string;
@@ -24,7 +23,7 @@ export class JwtManager {
 
   constructor(
     config: typeof JwtManager.prototype.config,
-    algorithm: "RS256" | "HS256" | "ES256" | "HS512"
+    algorithm: "RS256" | "HS256" | "ES256" | "HS512",
   ) {
     this.config = config;
     this.algorithm = algorithm;
@@ -35,7 +34,7 @@ export class JwtManager {
   // -------------------
   private generateToken(
     payload: Omit<TokenPayload, "iss" | "aud" | "iat" | "exp">,
-    expiresIn: string | number = "1h"
+    expiresIn: string | number = "1h",
   ): string {
     const signOptions: SignOptions = {
       algorithm: this.algorithm,
@@ -50,20 +49,31 @@ export class JwtManager {
   generateTokens(
     user: { id: string },
     accessTokenExpiry: string | number = "1h",
-    refreshTokenExpiry: string | number = "7d"
+    refreshTokenExpiry: string | number = "7d",
   ): AuthTokens {
-    const accessToken = this.generateToken({ sub: user.id, type: "access" }, accessTokenExpiry);
-    const refreshToken = this.generateToken({ sub: user.id, type: "refresh" }, refreshTokenExpiry);
+    const accessToken = this.generateToken(
+      { sub: user.id, type: "access" },
+      accessTokenExpiry,
+    );
+    const refreshToken = this.generateToken(
+      { sub: user.id, type: "refresh" },
+      refreshTokenExpiry,
+    );
 
     // Calculate the actual expiration time in seconds
     let expiresIn: number;
-    if (typeof accessTokenExpiry === 'string') {
+    if (typeof accessTokenExpiry === "string") {
       // Parse time strings like "1h", "30m", etc.
       const match = accessTokenExpiry.match(/^(\d+)([smhd])$/);
       if (match) {
         const value = globalThis.parseInt(match[1], NUMERIX.TEN);
         const unit = match[2];
-        const multipliers: Record<string, number> = { s: 1, m: 60, h: 3600, d: 86400 };
+        const multipliers: Record<string, number> = {
+          s: 1,
+          m: 60,
+          h: 3600,
+          d: 86400,
+        };
         expiresIn = value * multipliers[unit];
       } else {
         expiresIn = NUMERIX.THIRTY_SIX_HUNDERD; // Default to 1 hour
@@ -72,48 +82,63 @@ export class JwtManager {
       expiresIn = accessTokenExpiry;
     }
 
-    return { 
-      accessToken, 
+    return {
+      accessToken,
       refreshToken,
       expiresIn,
-      tokenType: "Bearer"
+      tokenType: "Bearer",
     };
   }
 
   // Generate access token
-  generateAccessToken(userId: string, expiresIn: string | number = "1h"): string {
+  generateAccessToken(
+    userId: string,
+    expiresIn: string | number = "1h",
+  ): string {
     return this.generateToken({ sub: userId, type: "access" }, expiresIn);
   }
 
   // Generate refresh token
-  generateRefreshToken(userId: string, expiresIn: string | number = "7d"): string {
+  generateRefreshToken(
+    userId: string,
+    expiresIn: string | number = "7d",
+  ): string {
     return this.generateToken({ sub: userId, type: "refresh" }, expiresIn);
   }
 
   // Generate verification token (email confirmation)
-  generateVerificationToken(userId: string, expiresIn: string | number = "24h"): string {
+  generateVerificationToken(
+    userId: string,
+    expiresIn: string | number = "24h",
+  ): string {
     return this.generateToken({ sub: userId, type: "verification" }, expiresIn);
   }
 
   // -------------------
   // Token Verification
   // -------------------
-  private verifyToken(token: string, tokenType: "access" | "refresh" | "verification"): TokenPayload {
+  private verifyToken(
+    token: string,
+    tokenType: "access" | "refresh" | "verification",
+  ): TokenPayload {
     const decoded = verify(token, this.config.publicKey, {
       algorithms: [this.algorithm],
       issuer: this.config.issuer,
       audience: this.config.audience,
     });
 
-    if (typeof decoded === "string") throw new Error(`Invalid ${tokenType} token payload`);
-    
+    if (typeof decoded === "string")
+      throw new Error(`Invalid ${tokenType} token payload`);
+
     const payload = decoded as JwtPayload;
-    
+
     // Verify the token type
     if (payload.type !== tokenType) {
-      throw new Error(`Invalid token type. Expected ${tokenType}, got ${payload.type}`);
+      throw new Error(
+        `Invalid token type. Expected ${tokenType}, got ${payload.type}`,
+      );
     }
-    
+
     return payload as TokenPayload;
   }
 
@@ -128,4 +153,4 @@ export class JwtManager {
   verifyVerificationToken(token: string): TokenPayload {
     return this.verifyToken(token, "verification");
   }
-}
+}

package/src/core/session/session.manager.ts

@@ -1,22 +1,27 @@
-
-import type { Session, SessionRepository, SessionConfig, CreateSessionData } from '@plyaz/types';
-
-
+import type {
+  Session,
+  SessionRepository,
+  SessionConfig,
+  CreateSessionData,
+} from "@plyaz/types";
 
 export class SessionManager {
   constructor(
     private sessionRepo: SessionRepository,
-    private config: SessionConfig
+    private config: SessionConfig,
   ) {}
 
-  async createSession(userId: string, deviceInfo: Record<string,unknown>): Promise<Session> {
+  async createSession(
+    userId: string,
+    deviceInfo: Record<string, unknown>,
+  ): Promise<Session> {
     await this.enforceSessionLimits(userId);
-    
+
     const sessionData: CreateSessionData = {
       userId,
-      provider: 'default',
+      provider: "default",
       expiresAt: new Date(Date.now() + this.config.sessionTTL),
-      metadata:deviceInfo,
+      metadata: deviceInfo,
     };
 
     return this.sessionRepo.create(sessionData);
@@ -45,12 +50,10 @@ export class SessionManager {
   private async enforceSessionLimits(userId: string): Promise<void> {
     const sessions = await this.sessionRepo.findByUserId(userId);
     if (sessions.length >= this.config.maxConcurrentSessions) {
-      const oldestSession = sessions.sort((a, b) => 
-        a.lastActivityAt.getTime() - b.lastActivityAt.getTime()
+      const oldestSession = sessions.sort(
+        (a, b) => a.lastActivityAt.getTime() - b.lastActivityAt.getTime(),
       )[0];
       await this.sessionRepo.delete(oldestSession.id);
     }
   }
-
- 
-}
+}