@geekmidas/auth 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,362 @@
+# @geekmidas/auth
+
+A comprehensive authentication library providing JWT token management, secure storage, and client-side token handling for TypeScript applications.
+
+## Features
+
+- **JWT Token Management**: Generate, verify, and refresh JWT access and refresh tokens
+- **Multiple Storage Options**: LocalStorage, Memory, and Cache-based token storage
+- **Automatic Token Refresh**: Seamless token refresh with expiration handling
+- **Type-Safe**: Full TypeScript support with complete type inference
+- **Framework Agnostic**: Works with any JavaScript framework or vanilla JS
+- **OpenAuth Integration**: Built on top of @openauthjs/openauth for standards compliance
+
+## Installation
+
+```bash
+pnpm add @geekmidas/auth
+```
+
+## Package Exports
+
+The package provides multiple entry points for different use cases:
+
+- `@geekmidas/auth` - Main client-side exports
+- `@geekmidas/auth/client` - Client-side token management
+- `@geekmidas/auth/server` - Server-side token management
+
+## Client-Side Usage
+
+### Basic Token Client
+
+```typescript
+import { TokenClient, LocalStorageTokenStorage } from '@geekmidas/auth/client';
+
+// Create a token client with localStorage
+const client = new TokenClient({
+  storage: new LocalStorageTokenStorage(),
+  refreshEndpoint: '/api/auth/refresh',
+  onTokenRefresh: (tokens) => {
+    console.log('Tokens refreshed:', tokens);
+  },
+  onTokenExpired: () => {
+    console.log('Tokens expired, redirect to login');
+    window.location.href = '/login';
+  },
+});
+
+// Store tokens after login
+await client.setTokens('access_token', 'refresh_token');
+
+// Get a valid access token (automatically refreshes if expired)
+const accessToken = await client.getValidAccessToken();
+
+// Create authorization headers
+const headers = await client.createValidAuthHeaders();
+// Returns: { Authorization: 'Bearer access_token' }
+```
+
+### Token Storage Options
+
+#### LocalStorage (Browser)
+
+```typescript
+import { LocalStorageTokenStorage } from '@geekmidas/auth/client';
+
+const storage = new LocalStorageTokenStorage(
+  'my_access_token',  // Custom access token key
+  'my_refresh_token'  // Custom refresh token key
+);
+```
+
+#### Memory Storage
+
+```typescript
+import { MemoryTokenStorage } from '@geekmidas/auth/client';
+
+// Ideal for server-side applications or testing
+const storage = new MemoryTokenStorage();
+```
+
+#### Cache Storage
+
+```typescript
+import { CacheTokenStorage } from '@geekmidas/auth/client';
+import { InMemoryCache } from '@geekmidas/cache/memory';
+
+const cache = new InMemoryCache<string>();
+const storage = new CacheTokenStorage(
+  cache,
+  'access_token',  // Access token key
+  'refresh_token'  // Refresh token key
+);
+
+// Supports TTL for automatic expiration
+await storage.setAccessToken('token', 3600); // 1 hour TTL
+```
+
+### Token Validation
+
+```typescript
+// Check if a token is expired
+const isExpired = client.isTokenExpired(token);
+
+// Get token expiration date
+const expiration = client.getTokenExpiration(token);
+console.log('Token expires at:', expiration);
+
+// Get a valid token (refreshes automatically if needed)
+const validToken = await client.getValidAccessToken();
+```
+
+### HTTP Client Integration
+
+```typescript
+import { TokenClient } from '@geekmidas/auth/client';
+
+class ApiClient {
+  constructor(private tokenClient: TokenClient) {}
+
+  async makeRequest(url: string, options: RequestInit = {}) {
+    const headers = await this.tokenClient.createValidAuthHeaders();
+    
+    return fetch(url, {
+      ...options,
+      headers: {
+        ...options.headers,
+        ...headers,
+      },
+    });
+  }
+}
+
+const apiClient = new ApiClient(tokenClient);
+const response = await apiClient.makeRequest('/api/users');
+```
+
+## Server-Side Usage
+
+### Token Manager
+
+```typescript
+import { TokenManager } from '@geekmidas/auth/server';
+
+const tokenManager = new TokenManager({
+  accessTokenSecret: process.env.ACCESS_TOKEN_SECRET!,
+  refreshTokenSecret: process.env.REFRESH_TOKEN_SECRET!,
+  accessTokenExpiresIn: '15m',
+  refreshTokenExpiresIn: '7d',
+});
+
+// Generate token pair
+const tokens = tokenManager.generateTokenPair({
+  userId: 'user123',
+  email: 'user@example.com',
+  role: 'admin',
+});
+
+// Verify tokens
+try {
+  const payload = tokenManager.verifyAccessToken(accessToken);
+  console.log('User ID:', payload.userId);
+} catch (error) {
+  console.error('Invalid token:', error.message);
+}
+
+// Refresh access token
+try {
+  const newAccessToken = tokenManager.refreshAccessToken(refreshToken);
+} catch (error) {
+  console.error('Refresh failed:', error.message);
+}
+```
+
+### Token Validation Middleware
+
+```typescript
+import { TokenManager } from '@geekmidas/auth/server';
+
+const tokenManager = new TokenManager({
+  accessTokenSecret: process.env.ACCESS_TOKEN_SECRET!,
+  refreshTokenSecret: process.env.REFRESH_TOKEN_SECRET!,
+});
+
+function authenticateToken(req: Request, res: Response, next: NextFunction) {
+  const authHeader = req.headers.authorization;
+  const token = authHeader && authHeader.split(' ')[1];
+
+  if (!token) {
+    return res.status(401).json({ error: 'Access token required' });
+  }
+
+  try {
+    const payload = tokenManager.verifyAccessToken(token);
+    req.user = payload;
+    next();
+  } catch (error) {
+    return res.status(403).json({ error: 'Invalid or expired token' });
+  }
+}
+```
+
+## API Reference
+
+### TokenClient
+
+The main client for managing tokens on the client-side.
+
+#### Constructor Options
+
+```typescript
+interface TokenClientOptions {
+  storage?: TokenStorage;           // Token storage implementation
+  refreshEndpoint?: string;         // API endpoint for token refresh
+  onTokenRefresh?: (tokens: {       // Callback on successful refresh
+    accessToken: string;
+    refreshToken?: string;
+  }) => void;
+  onTokenExpired?: () => void;      // Callback when tokens expire
+}
+```
+
+#### Methods
+
+- `getAccessToken(): Promise<string | null>` - Get stored access token
+- `getRefreshToken(): Promise<string | null>` - Get stored refresh token
+- `setTokens(accessToken, refreshToken?, accessTtl?, refreshTtl?): Promise<void>` - Store tokens
+- `clearTokens(): Promise<void>` - Clear all stored tokens
+- `isTokenExpired(token: string): boolean` - Check if token is expired
+- `getTokenExpiration(token: string): Date | null` - Get token expiration date
+- `refreshTokens(): Promise<boolean>` - Refresh tokens via API
+- `getValidAccessToken(): Promise<string | null>` - Get valid token (auto-refresh)
+- `createAuthHeaders(): Promise<Record<string, string>>` - Create auth headers
+- `createValidAuthHeaders(): Promise<Record<string, string>>` - Create auth headers with valid token
+
+### TokenStorage Interface
+
+```typescript
+interface TokenStorage {
+  getAccessToken(): Promise<string | null> | string | null;
+  setAccessToken(token: string, ttl?: number): Promise<void> | void;
+  getRefreshToken(): Promise<string | null> | string | null;
+  setRefreshToken(token: string, ttl?: number): Promise<void> | void;
+  clearTokens(): Promise<void> | void;
+}
+```
+
+### TokenManager
+
+Server-side JWT token management.
+
+#### Constructor Options
+
+```typescript
+interface TokenManagerOptions {
+  accessTokenSecret: string;        // Secret for signing access tokens
+  refreshTokenSecret: string;       // Secret for signing refresh tokens
+  accessTokenExpiresIn?: string;    // Access token expiration (default: '15m')
+  refreshTokenExpiresIn?: string;   // Refresh token expiration (default: '7d')
+}
+```
+
+#### Methods
+
+- `generateTokenPair(payload: TokenPayload): TokenPair` - Generate access and refresh tokens
+- `verifyAccessToken(token: string): DecodedToken` - Verify and decode access token
+- `verifyRefreshToken(token: string): DecodedToken` - Verify and decode refresh token
+- `refreshAccessToken(refreshToken: string): string` - Generate new access token from refresh token
+- `decodeToken(token: string): DecodedToken | null` - Decode token without verification
+- `isTokenExpired(token: string): boolean` - Check if token is expired
+- `getTokenExpiration(token: string): Date | null` - Get token expiration date
+
+### Types
+
+```typescript
+interface TokenPayload {
+  userId: string;
+  email?: string;
+  [key: string]: any;
+}
+
+interface TokenPair {
+  accessToken: string;
+  refreshToken: string;
+}
+
+interface DecodedToken extends TokenPayload {
+  iat: number;  // Issued at
+  exp: number;  // Expiration time
+}
+```
+
+## Error Handling
+
+The library provides descriptive error messages for common scenarios:
+
+```typescript
+try {
+  const payload = tokenManager.verifyAccessToken(token);
+} catch (error) {
+  if (error.message.includes('Invalid access token')) {
+    // Handle invalid token
+  } else if (error.message.includes('expired')) {
+    // Handle expired token
+  }
+}
+```
+
+## Security Best Practices
+
+1. **Use Strong Secrets**: Ensure your JWT secrets are cryptographically secure and different for access and refresh tokens.
+
+2. **Short Access Token Expiration**: Keep access tokens short-lived (15 minutes recommended).
+
+3. **Secure Token Storage**: Use appropriate storage based on your environment:
+   - Browser: LocalStorage or secure cookies
+   - Server: Memory or secure cache
+   - Mobile: Secure keychain/keystore
+
+4. **HTTPS Only**: Always use HTTPS in production to prevent token interception.
+
+5. **Token Rotation**: Implement refresh token rotation for enhanced security.
+
+## Testing
+
+The package includes comprehensive test utilities:
+
+```typescript
+import { MemoryTokenStorage, TokenClient } from '@geekmidas/auth/client';
+
+// Use memory storage for tests
+const storage = new MemoryTokenStorage();
+const client = new TokenClient({ storage });
+
+// Mock refresh endpoint with MSW
+import { http, HttpResponse } from 'msw';
+
+const server = setupServer(
+  http.post('/auth/refresh', () => {
+    return HttpResponse.json({
+      accessToken: 'new-access-token',
+      refreshToken: 'new-refresh-token',
+    });
+  }),
+);
+```
+
+## Migration Guide
+
+### From v0.0.x
+
+The auth package is currently in initial development. Breaking changes may occur between minor versions until v1.0.0.
+
+## Dependencies
+
+- `@openauthjs/openauth` - OpenAuth integration
+- `@geekmidas/cache` - Cache storage support  
+- `jsonwebtoken` - JWT token operations
+- `@types/ms` - Time duration types
+
+## License
+
+MIT License - see the LICENSE file for details.

package/dist/__tests__/cacheTokenStorage.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/cacheTokenStorage.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/client.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/client.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/tokenManager.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/tokenManager.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cacheTokenStorage-BlpcZwef.d.mts

@@ -0,0 +1,70 @@
+import { Cache } from "@geekmidas/cache";
+
+//#region src/client.d.ts
+interface TokenStorage {
+  getAccessToken(): Promise<string | null> | string | null;
+  setAccessToken(token: string, ttl?: number): Promise<void> | void;
+  getRefreshToken(): Promise<string | null> | string | null;
+  setRefreshToken(token: string, ttl?: number): Promise<void> | void;
+  clearTokens(): Promise<void> | void;
+}
+declare class LocalStorageTokenStorage implements TokenStorage {
+  private accessTokenKey;
+  private refreshTokenKey;
+  constructor(accessTokenKey?: string, refreshTokenKey?: string);
+  getAccessToken(): string | null;
+  setAccessToken(token: string, ttl?: number): void;
+  getRefreshToken(): string | null;
+  setRefreshToken(token: string, ttl?: number): void;
+  clearTokens(): void;
+}
+declare class MemoryTokenStorage implements TokenStorage {
+  private accessToken;
+  private refreshToken;
+  getAccessToken(): string | null;
+  setAccessToken(token: string, ttl?: number): void;
+  getRefreshToken(): string | null;
+  setRefreshToken(token: string, ttl?: number): void;
+  clearTokens(): void;
+}
+interface TokenClientOptions {
+  storage?: TokenStorage;
+  refreshEndpoint?: string;
+  onTokenRefresh?: (tokens: {
+    accessToken: string;
+    refreshToken?: string;
+  }) => void;
+  onTokenExpired?: () => void;
+}
+declare class TokenClient {
+  private storage;
+  private refreshEndpoint?;
+  private onTokenRefresh?;
+  private onTokenExpired?;
+  constructor(options?: TokenClientOptions);
+  getAccessToken(): Promise<string | null>;
+  getRefreshToken(): Promise<string | null>;
+  setTokens(accessToken: string, refreshToken?: string, accessTtl?: number, refreshTtl?: number): Promise<void>;
+  clearTokens(): Promise<void>;
+  isTokenExpired(token: string): boolean;
+  getTokenExpiration(token: string): Date | null;
+  refreshTokens(): Promise<boolean>;
+  getValidAccessToken(): Promise<string | null>;
+  createAuthHeaders(): Promise<Record<string, string>>;
+  createValidAuthHeaders(): Promise<Record<string, string>>;
+}
+//#endregion
+//#region src/cacheTokenStorage.d.ts
+declare class CacheTokenStorage implements TokenStorage {
+  private cache;
+  private accessTokenKey;
+  private refreshTokenKey;
+  constructor(cache: Cache<string>, accessTokenKey?: string, refreshTokenKey?: string);
+  getAccessToken(): Promise<string | null>;
+  setAccessToken(token: string, ttl?: number): Promise<void>;
+  getRefreshToken(): Promise<string | null>;
+  setRefreshToken(token: string, ttl?: number): Promise<void>;
+  clearTokens(): Promise<void>;
+}
+//#endregion
+export { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage };

package/dist/cacheTokenStorage-yNUpDD8W.d.cts

@@ -0,0 +1,70 @@
+import { Cache } from "@geekmidas/cache";
+
+//#region src/client.d.ts
+interface TokenStorage {
+  getAccessToken(): Promise<string | null> | string | null;
+  setAccessToken(token: string, ttl?: number): Promise<void> | void;
+  getRefreshToken(): Promise<string | null> | string | null;
+  setRefreshToken(token: string, ttl?: number): Promise<void> | void;
+  clearTokens(): Promise<void> | void;
+}
+declare class LocalStorageTokenStorage implements TokenStorage {
+  private accessTokenKey;
+  private refreshTokenKey;
+  constructor(accessTokenKey?: string, refreshTokenKey?: string);
+  getAccessToken(): string | null;
+  setAccessToken(token: string, ttl?: number): void;
+  getRefreshToken(): string | null;
+  setRefreshToken(token: string, ttl?: number): void;
+  clearTokens(): void;
+}
+declare class MemoryTokenStorage implements TokenStorage {
+  private accessToken;
+  private refreshToken;
+  getAccessToken(): string | null;
+  setAccessToken(token: string, ttl?: number): void;
+  getRefreshToken(): string | null;
+  setRefreshToken(token: string, ttl?: number): void;
+  clearTokens(): void;
+}
+interface TokenClientOptions {
+  storage?: TokenStorage;
+  refreshEndpoint?: string;
+  onTokenRefresh?: (tokens: {
+    accessToken: string;
+    refreshToken?: string;
+  }) => void;
+  onTokenExpired?: () => void;
+}
+declare class TokenClient {
+  private storage;
+  private refreshEndpoint?;
+  private onTokenRefresh?;
+  private onTokenExpired?;
+  constructor(options?: TokenClientOptions);
+  getAccessToken(): Promise<string | null>;
+  getRefreshToken(): Promise<string | null>;
+  setTokens(accessToken: string, refreshToken?: string, accessTtl?: number, refreshTtl?: number): Promise<void>;
+  clearTokens(): Promise<void>;
+  isTokenExpired(token: string): boolean;
+  getTokenExpiration(token: string): Date | null;
+  refreshTokens(): Promise<boolean>;
+  getValidAccessToken(): Promise<string | null>;
+  createAuthHeaders(): Promise<Record<string, string>>;
+  createValidAuthHeaders(): Promise<Record<string, string>>;
+}
+//#endregion
+//#region src/cacheTokenStorage.d.ts
+declare class CacheTokenStorage implements TokenStorage {
+  private cache;
+  private accessTokenKey;
+  private refreshTokenKey;
+  constructor(cache: Cache<string>, accessTokenKey?: string, refreshTokenKey?: string);
+  getAccessToken(): Promise<string | null>;
+  setAccessToken(token: string, ttl?: number): Promise<void>;
+  getRefreshToken(): Promise<string | null>;
+  setRefreshToken(token: string, ttl?: number): Promise<void>;
+  clearTokens(): Promise<void>;
+}
+//#endregion
+export { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage };

package/dist/cacheTokenStorage.d.cts

@@ -0,0 +1,2 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-yNUpDD8W.cjs";
+export { CacheTokenStorage };

package/dist/cacheTokenStorage.d.mts

@@ -0,0 +1,2 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-BlpcZwef.mjs";
+export { CacheTokenStorage };

package/dist/client.d.cts

@@ -0,0 +1,2 @@
+import { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage } from "./cacheTokenStorage-yNUpDD8W.cjs";
+export { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage };

package/dist/client.d.mts

@@ -0,0 +1,2 @@
+import { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage } from "./cacheTokenStorage-BlpcZwef.mjs";
+export { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage };

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+import { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage } from "./cacheTokenStorage-yNUpDD8W.cjs";
+import { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload } from "./tokenManager-mpzJKLvX.cjs";
+export { CacheTokenStorage, DecodedToken, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenManager, TokenManagerOptions, TokenPair, TokenPayload, TokenStorage };

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenStorage } from "./cacheTokenStorage-BlpcZwef.mjs";
+import { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload } from "./tokenManager-CCcFk2Py.mjs";
+export { CacheTokenStorage, DecodedToken, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenClientOptions, TokenManager, TokenManagerOptions, TokenPair, TokenPayload, TokenStorage };

package/dist/playground.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/playground.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/server.d.cts

@@ -0,0 +1,3 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-yNUpDD8W.cjs";
+import { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload } from "./tokenManager-mpzJKLvX.cjs";
+export { CacheTokenStorage, DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload };

package/dist/server.d.mts

@@ -0,0 +1,3 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-BlpcZwef.mjs";
+import { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload } from "./tokenManager-CCcFk2Py.mjs";
+export { CacheTokenStorage, DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload };

package/dist/tokenManager-CCcFk2Py.d.mts

@@ -0,0 +1,38 @@
+import ms from "ms";
+
+//#region src/tokenManager.d.ts
+interface TokenPayload {
+  userId: string;
+  email?: string;
+  [key: string]: any;
+}
+interface TokenPair {
+  accessToken: string;
+  refreshToken: string;
+}
+interface TokenManagerOptions {
+  accessTokenSecret: string;
+  refreshTokenSecret: string;
+  accessTokenExpiresIn?: ms.StringValue;
+  refreshTokenExpiresIn?: ms.StringValue;
+}
+interface DecodedToken extends TokenPayload {
+  iat: number;
+  exp: number;
+}
+declare class TokenManager {
+  private accessTokenSecret;
+  private refreshTokenSecret;
+  private accessTokenExpiresIn;
+  private refreshTokenExpiresIn;
+  constructor(options: TokenManagerOptions);
+  generateTokenPair(payload: TokenPayload): TokenPair;
+  verifyAccessToken(token: string): DecodedToken;
+  verifyRefreshToken(token: string): DecodedToken;
+  refreshAccessToken(refreshToken: string): string;
+  decodeToken(token: string): DecodedToken | null;
+  isTokenExpired(token: string): boolean;
+  getTokenExpiration(token: string): Date | null;
+}
+//#endregion
+export { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload };

package/dist/tokenManager-mpzJKLvX.d.cts

@@ -0,0 +1,38 @@
+import ms from "ms";
+
+//#region src/tokenManager.d.ts
+interface TokenPayload {
+  userId: string;
+  email?: string;
+  [key: string]: any;
+}
+interface TokenPair {
+  accessToken: string;
+  refreshToken: string;
+}
+interface TokenManagerOptions {
+  accessTokenSecret: string;
+  refreshTokenSecret: string;
+  accessTokenExpiresIn?: ms.StringValue;
+  refreshTokenExpiresIn?: ms.StringValue;
+}
+interface DecodedToken extends TokenPayload {
+  iat: number;
+  exp: number;
+}
+declare class TokenManager {
+  private accessTokenSecret;
+  private refreshTokenSecret;
+  private accessTokenExpiresIn;
+  private refreshTokenExpiresIn;
+  constructor(options: TokenManagerOptions);
+  generateTokenPair(payload: TokenPayload): TokenPair;
+  verifyAccessToken(token: string): DecodedToken;
+  verifyRefreshToken(token: string): DecodedToken;
+  refreshAccessToken(refreshToken: string): string;
+  decodeToken(token: string): DecodedToken | null;
+  isTokenExpired(token: string): boolean;
+  getTokenExpiration(token: string): Date | null;
+}
+//#endregion
+export { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload };

package/dist/tokenManager.d.cts

@@ -0,0 +1,2 @@
+import { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload } from "./tokenManager-mpzJKLvX.cjs";
+export { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload };

package/dist/tokenManager.d.mts

@@ -0,0 +1,2 @@
+import { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload } from "./tokenManager-CCcFk2Py.mjs";
+export { DecodedToken, TokenManager, TokenManagerOptions, TokenPair, TokenPayload };

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@geekmidas/auth",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs",
-      "types": "./src/index.ts"
+      "require": "./dist/index.cjs"
     },
     "./server": {
+      "types": "./dist/server.d.ts",
       "import": "./dist/server.mjs",
-      "require": "./dist/server.cjs",
-      "types": "./src/server.ts"
+      "require": "./dist/server.cjs"
     },
     "./client": {
+      "types": "./dist/client.d.ts",
       "import": "./dist/client.mjs",
-      "require": "./dist/client.cjs",
-      "types": "./src/client.ts"
+      "require": "./dist/client.cjs"
     }
   },
   "publishConfig": {
@@ -27,7 +27,7 @@
     "@openauthjs/openauth": "~0.4.3",
     "jsonwebtoken": "^9.0.2",
     "@types/ms": "~2.1.0",
-    "@geekmidas/cache": "0.0.3"
+    "@geekmidas/cache": "0.0.4"
   },
   "devDependencies": {
     "@types/jsonwebtoken": "^9.0.5"

package/src/__tests__/cacheTokenStorage.spec.ts

@@ -15,32 +15,32 @@ describe('CacheTokenStorage', () => {
   describe('access token operations', () => {
     it('should store and retrieve access token', async () => {
       await storage.setAccessToken('test-access-token');
-      
+
       const token = await storage.getAccessToken();
-      
+
       expect(token).toBe('test-access-token');
     });
 
     it('should return null when no access token exists', async () => {
       const token = await storage.getAccessToken();
-      
+
       expect(token).toBeNull();
     });
 
     it('should store access token with TTL', async () => {
       await storage.setAccessToken('test-access-token', 3600);
-      
+
       const token = await storage.getAccessToken();
-      
+
       expect(token).toBe('test-access-token');
     });
 
     it('should overwrite existing access token', async () => {
       await storage.setAccessToken('first-token');
       await storage.setAccessToken('second-token');
-      
+
       const token = await storage.getAccessToken();
-      
+
       expect(token).toBe('second-token');
     });
   });
@@ -48,32 +48,32 @@ describe('CacheTokenStorage', () => {
   describe('refresh token operations', () => {
     it('should store and retrieve refresh token', async () => {
       await storage.setRefreshToken('test-refresh-token');
-      
+
       const token = await storage.getRefreshToken();
-      
+
       expect(token).toBe('test-refresh-token');
     });
 
     it('should return null when no refresh token exists', async () => {
       const token = await storage.getRefreshToken();
-      
+
       expect(token).toBeNull();
     });
 
     it('should store refresh token with TTL', async () => {
       await storage.setRefreshToken('test-refresh-token', 7200);
-      
+
       const token = await storage.getRefreshToken();
-      
+
       expect(token).toBe('test-refresh-token');
     });
 
     it('should overwrite existing refresh token', async () => {
       await storage.setRefreshToken('first-refresh-token');
       await storage.setRefreshToken('second-refresh-token');
-      
+
       const token = await storage.getRefreshToken();
-      
+
       expect(token).toBe('second-refresh-token');
     });
   });
@@ -82,10 +82,10 @@ describe('CacheTokenStorage', () => {
     it('should store both tokens independently', async () => {
       await storage.setAccessToken('access-token');
       await storage.setRefreshToken('refresh-token');
-      
+
       const accessToken = await storage.getAccessToken();
       const refreshToken = await storage.getRefreshToken();
-      
+
       expect(accessToken).toBe('access-token');
       expect(refreshToken).toBe('refresh-token');
     });
@@ -93,24 +93,24 @@ describe('CacheTokenStorage', () => {
     it('should clear both tokens', async () => {
       await storage.setAccessToken('access-token');
       await storage.setRefreshToken('refresh-token');
-      
+
       await storage.clearTokens();
-      
+
       const accessToken = await storage.getAccessToken();
       const refreshToken = await storage.getRefreshToken();
-      
+
       expect(accessToken).toBeNull();
       expect(refreshToken).toBeNull();
     });
 
     it('should clear tokens when some are missing', async () => {
       await storage.setAccessToken('access-token');
-      
+
       await storage.clearTokens();
-      
+
       const accessToken = await storage.getAccessToken();
       const refreshToken = await storage.getRefreshToken();
-      
+
       expect(accessToken).toBeNull();
       expect(refreshToken).toBeNull();
     });
@@ -177,7 +177,7 @@ describe('CacheTokenStorage', () => {
     it('should work with multiple cache instances', async () => {
       const cache1 = new InMemoryCache<string>();
       const cache2 = new InMemoryCache<string>();
-      
+
       const storage1 = new CacheTokenStorage(cache1);
       const storage2 = new CacheTokenStorage(cache2);
 
@@ -210,4 +210,4 @@ describe('CacheTokenStorage', () => {
       expect(refreshToken).toBe('initial-refresh');
     });
   });
-});
+});

package/src/index.ts

@@ -1,3 +1,3 @@
 export * from './tokenManager.js';
 export * from './client.js';
-export * from './cacheTokenStorage.js';
+export * from './cacheTokenStorage.js';

package/src/server.ts

@@ -6,6 +6,4 @@ export {
   type DecodedToken,
 } from './tokenManager.js';
 
-export {
-  CacheTokenStorage,
-} from './cacheTokenStorage.js';
+export { CacheTokenStorage } from './cacheTokenStorage.js';