@geekmidas/auth 0.0.1

package/dist/client-DjNZS6vZ.mjs

@@ -0,0 +1,137 @@
+//#region src/client.ts
+var LocalStorageTokenStorage = class {
+	accessTokenKey;
+	refreshTokenKey;
+	constructor(accessTokenKey = "access_token", refreshTokenKey = "refresh_token") {
+		this.accessTokenKey = accessTokenKey;
+		this.refreshTokenKey = refreshTokenKey;
+	}
+	getAccessToken() {
+		if (typeof window === "undefined") return null;
+		return localStorage.getItem(this.accessTokenKey);
+	}
+	setAccessToken(token, ttl) {
+		if (typeof window === "undefined") return;
+		localStorage.setItem(this.accessTokenKey, token);
+	}
+	getRefreshToken() {
+		if (typeof window === "undefined") return null;
+		return localStorage.getItem(this.refreshTokenKey);
+	}
+	setRefreshToken(token, ttl) {
+		if (typeof window === "undefined") return;
+		localStorage.setItem(this.refreshTokenKey, token);
+	}
+	clearTokens() {
+		if (typeof window === "undefined") return;
+		localStorage.removeItem(this.accessTokenKey);
+		localStorage.removeItem(this.refreshTokenKey);
+	}
+};
+var MemoryTokenStorage = class {
+	accessToken = null;
+	refreshToken = null;
+	getAccessToken() {
+		return this.accessToken;
+	}
+	setAccessToken(token, ttl) {
+		this.accessToken = token;
+	}
+	getRefreshToken() {
+		return this.refreshToken;
+	}
+	setRefreshToken(token, ttl) {
+		this.refreshToken = token;
+	}
+	clearTokens() {
+		this.accessToken = null;
+		this.refreshToken = null;
+	}
+};
+var TokenClient = class {
+	storage;
+	refreshEndpoint;
+	onTokenRefresh;
+	onTokenExpired;
+	constructor(options = {}) {
+		this.storage = options.storage || new LocalStorageTokenStorage();
+		this.refreshEndpoint = options.refreshEndpoint;
+		this.onTokenRefresh = options.onTokenRefresh;
+		this.onTokenExpired = options.onTokenExpired;
+	}
+	async getAccessToken() {
+		return await this.storage.getAccessToken();
+	}
+	async getRefreshToken() {
+		return await this.storage.getRefreshToken();
+	}
+	async setTokens(accessToken, refreshToken, accessTtl, refreshTtl) {
+		await this.storage.setAccessToken(accessToken, accessTtl);
+		if (refreshToken) await this.storage.setRefreshToken(refreshToken, refreshTtl);
+	}
+	async clearTokens() {
+		await this.storage.clearTokens();
+	}
+	isTokenExpired(token) {
+		try {
+			const payload = JSON.parse(atob(token.split(".")[1]));
+			const now = Math.floor(Date.now() / 1e3);
+			return payload.exp < now;
+		} catch {
+			return true;
+		}
+	}
+	getTokenExpiration(token) {
+		try {
+			const payload = JSON.parse(atob(token.split(".")[1]));
+			return new Date(payload.exp * 1e3);
+		} catch {
+			return null;
+		}
+	}
+	async refreshTokens() {
+		const refreshToken = await this.getRefreshToken();
+		if (!refreshToken || !this.refreshEndpoint) return false;
+		try {
+			const response = await fetch(this.refreshEndpoint, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ refreshToken })
+			});
+			if (!response.ok) throw new Error("Failed to refresh token");
+			const data = await response.json();
+			const { accessToken, refreshToken: newRefreshToken } = data;
+			await this.setTokens(accessToken, newRefreshToken);
+			if (this.onTokenRefresh) this.onTokenRefresh({
+				accessToken,
+				refreshToken: newRefreshToken
+			});
+			return true;
+		} catch (error) {
+			await this.clearTokens();
+			if (this.onTokenExpired) this.onTokenExpired();
+			return false;
+		}
+	}
+	async getValidAccessToken() {
+		const accessToken = await this.getAccessToken();
+		if (!accessToken) return null;
+		if (this.isTokenExpired(accessToken)) {
+			const refreshed = await this.refreshTokens();
+			if (!refreshed) return null;
+			return await this.getAccessToken();
+		}
+		return accessToken;
+	}
+	async createAuthHeaders() {
+		const token = await this.getAccessToken();
+		return token ? { Authorization: `Bearer ${token}` } : {};
+	}
+	async createValidAuthHeaders() {
+		const token = await this.getValidAccessToken();
+		return token ? { Authorization: `Bearer ${token}` } : {};
+	}
+};
+
+//#endregion
+export { LocalStorageTokenStorage, MemoryTokenStorage, TokenClient };

package/dist/client.cjs

@@ -0,0 +1,7 @@
+const require_cacheTokenStorage = require('./cacheTokenStorage-CvptztkW.cjs');
+const require_client = require('./client-DaiUm0UZ.cjs');
+
+exports.CacheTokenStorage = require_cacheTokenStorage.CacheTokenStorage;
+exports.LocalStorageTokenStorage = require_client.LocalStorageTokenStorage;
+exports.MemoryTokenStorage = require_client.MemoryTokenStorage;
+exports.TokenClient = require_client.TokenClient;

package/dist/client.mjs

@@ -0,0 +1,4 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-Ca05vf3T.mjs";
+import { LocalStorageTokenStorage, MemoryTokenStorage, TokenClient } from "./client-DjNZS6vZ.mjs";
+
+export { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient };

package/dist/index.cjs

@@ -0,0 +1,9 @@
+const require_cacheTokenStorage = require('./cacheTokenStorage-CvptztkW.cjs');
+const require_client = require('./client-DaiUm0UZ.cjs');
+const require_tokenManager = require('./tokenManager-B60gFnEF.cjs');
+
+exports.CacheTokenStorage = require_cacheTokenStorage.CacheTokenStorage;
+exports.LocalStorageTokenStorage = require_client.LocalStorageTokenStorage;
+exports.MemoryTokenStorage = require_client.MemoryTokenStorage;
+exports.TokenClient = require_client.TokenClient;
+exports.TokenManager = require_tokenManager.TokenManager;

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-Ca05vf3T.mjs";
+import { LocalStorageTokenStorage, MemoryTokenStorage, TokenClient } from "./client-DjNZS6vZ.mjs";
+import { TokenManager } from "./tokenManager-BVXxfHRa.mjs";
+
+export { CacheTokenStorage, LocalStorageTokenStorage, MemoryTokenStorage, TokenClient, TokenManager };

package/dist/server.cjs

@@ -0,0 +1,5 @@
+const require_cacheTokenStorage = require('./cacheTokenStorage-CvptztkW.cjs');
+const require_tokenManager = require('./tokenManager-B60gFnEF.cjs');
+
+exports.CacheTokenStorage = require_cacheTokenStorage.CacheTokenStorage;
+exports.TokenManager = require_tokenManager.TokenManager;

package/dist/server.mjs

@@ -0,0 +1,4 @@
+import { CacheTokenStorage } from "./cacheTokenStorage-Ca05vf3T.mjs";
+import { TokenManager } from "./tokenManager-BVXxfHRa.mjs";
+
+export { CacheTokenStorage, TokenManager };

package/dist/tokenManager-B60gFnEF.cjs

@@ -0,0 +1,69 @@
+const require_chunk = require('./chunk-DWy1uDak.cjs');
+const jsonwebtoken = require_chunk.__toESM(require("jsonwebtoken"));
+
+//#region src/tokenManager.ts
+var TokenManager = class {
+	accessTokenSecret;
+	refreshTokenSecret;
+	accessTokenExpiresIn;
+	refreshTokenExpiresIn;
+	constructor(options) {
+		this.accessTokenSecret = options.accessTokenSecret;
+		this.refreshTokenSecret = options.refreshTokenSecret;
+		this.accessTokenExpiresIn = options.accessTokenExpiresIn || "15m";
+		this.refreshTokenExpiresIn = options.refreshTokenExpiresIn || "7d";
+	}
+	generateTokenPair(payload) {
+		const accessToken = jsonwebtoken.default.sign(payload, this.accessTokenSecret, { expiresIn: this.accessTokenExpiresIn });
+		const refreshToken = jsonwebtoken.default.sign(payload, this.refreshTokenSecret, { expiresIn: this.refreshTokenExpiresIn });
+		return {
+			accessToken,
+			refreshToken
+		};
+	}
+	verifyAccessToken(token) {
+		try {
+			return jsonwebtoken.default.verify(token, this.accessTokenSecret);
+		} catch (error) {
+			throw new Error(`Invalid access token: ${error.message}`);
+		}
+	}
+	verifyRefreshToken(token) {
+		try {
+			return jsonwebtoken.default.verify(token, this.refreshTokenSecret);
+		} catch (error) {
+			throw new Error(`Invalid refresh token: ${error.message}`);
+		}
+	}
+	refreshAccessToken(refreshToken) {
+		const decoded = this.verifyRefreshToken(refreshToken);
+		const { iat, exp,...payload } = decoded;
+		return jsonwebtoken.default.sign(payload, this.accessTokenSecret, { expiresIn: this.accessTokenExpiresIn });
+	}
+	decodeToken(token) {
+		try {
+			return jsonwebtoken.default.decode(token);
+		} catch {
+			return null;
+		}
+	}
+	isTokenExpired(token) {
+		const decoded = this.decodeToken(token);
+		if (!decoded) return true;
+		const now = Math.floor(Date.now() / 1e3);
+		return decoded.exp < now;
+	}
+	getTokenExpiration(token) {
+		const decoded = this.decodeToken(token);
+		if (!decoded) return null;
+		return new Date(decoded.exp * 1e3);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'TokenManager', {
+  enumerable: true,
+  get: function () {
+    return TokenManager;
+  }
+});

package/dist/tokenManager-BVXxfHRa.mjs

@@ -0,0 +1,63 @@
+import jwt from "jsonwebtoken";
+
+//#region src/tokenManager.ts
+var TokenManager = class {
+	accessTokenSecret;
+	refreshTokenSecret;
+	accessTokenExpiresIn;
+	refreshTokenExpiresIn;
+	constructor(options) {
+		this.accessTokenSecret = options.accessTokenSecret;
+		this.refreshTokenSecret = options.refreshTokenSecret;
+		this.accessTokenExpiresIn = options.accessTokenExpiresIn || "15m";
+		this.refreshTokenExpiresIn = options.refreshTokenExpiresIn || "7d";
+	}
+	generateTokenPair(payload) {
+		const accessToken = jwt.sign(payload, this.accessTokenSecret, { expiresIn: this.accessTokenExpiresIn });
+		const refreshToken = jwt.sign(payload, this.refreshTokenSecret, { expiresIn: this.refreshTokenExpiresIn });
+		return {
+			accessToken,
+			refreshToken
+		};
+	}
+	verifyAccessToken(token) {
+		try {
+			return jwt.verify(token, this.accessTokenSecret);
+		} catch (error) {
+			throw new Error(`Invalid access token: ${error.message}`);
+		}
+	}
+	verifyRefreshToken(token) {
+		try {
+			return jwt.verify(token, this.refreshTokenSecret);
+		} catch (error) {
+			throw new Error(`Invalid refresh token: ${error.message}`);
+		}
+	}
+	refreshAccessToken(refreshToken) {
+		const decoded = this.verifyRefreshToken(refreshToken);
+		const { iat, exp,...payload } = decoded;
+		return jwt.sign(payload, this.accessTokenSecret, { expiresIn: this.accessTokenExpiresIn });
+	}
+	decodeToken(token) {
+		try {
+			return jwt.decode(token);
+		} catch {
+			return null;
+		}
+	}
+	isTokenExpired(token) {
+		const decoded = this.decodeToken(token);
+		if (!decoded) return true;
+		const now = Math.floor(Date.now() / 1e3);
+		return decoded.exp < now;
+	}
+	getTokenExpiration(token) {
+		const decoded = this.decodeToken(token);
+		if (!decoded) return null;
+		return new Date(decoded.exp * 1e3);
+	}
+};
+
+//#endregion
+export { TokenManager };

package/dist/tokenManager.cjs

@@ -0,0 +1,3 @@
+const require_tokenManager = require('./tokenManager-B60gFnEF.cjs');
+
+exports.TokenManager = require_tokenManager.TokenManager;

package/dist/tokenManager.mjs

@@ -0,0 +1,3 @@
+import { TokenManager } from "./tokenManager-BVXxfHRa.mjs";
+
+export { TokenManager };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@geekmidas/auth",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./src/index.ts"
+    },
+    "./server": {
+      "import": "./dist/server.mjs",
+      "require": "./dist/server.cjs",
+      "types": "./src/server.ts"
+    },
+    "./client": {
+      "import": "./dist/client.mjs",
+      "require": "./dist/client.cjs",
+      "types": "./src/client.ts"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@openauthjs/openauth": "~0.4.3",
+    "jsonwebtoken": "^9.0.2",
+    "@types/ms": "~2.1.0",
+    "@geekmidas/cache": "0.0.3"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.5"
+  },
+  "scripts": {
+    "play": "tsx src/playground.ts"
+  }
+}

package/src/__tests__/cacheTokenStorage.spec.ts

@@ -0,0 +1,213 @@
+import type { Cache } from '@geekmidas/cache';
+import { InMemoryCache } from '@geekmidas/cache/memory';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { CacheTokenStorage } from '../cacheTokenStorage.ts';
+
+describe('CacheTokenStorage', () => {
+  let storage: CacheTokenStorage;
+  let cache: Cache<string>;
+
+  beforeEach(() => {
+    cache = new InMemoryCache<string>();
+    storage = new CacheTokenStorage(cache);
+  });
+
+  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');
+    });
+  });
+
+  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');
+    });
+  });
+
+  describe('token lifecycle', () => {
+    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');
+    });
+
+    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();
+    });
+  });
+
+  describe('custom storage keys', () => {
+    it('should use custom keys for token storage', async () => {
+      const customStorage = new CacheTokenStorage(
+        cache,
+        'custom_access_key',
+        'custom_refresh_key',
+      );
+
+      await customStorage.setAccessToken('access-token');
+      await customStorage.setRefreshToken('refresh-token');
+
+      const accessToken = await customStorage.getAccessToken();
+      const refreshToken = await customStorage.getRefreshToken();
+
+      expect(accessToken).toBe('access-token');
+      expect(refreshToken).toBe('refresh-token');
+    });
+
+    it('should isolate tokens between different storage instances', async () => {
+      const defaultStorage = new CacheTokenStorage(cache);
+      const customStorage = new CacheTokenStorage(
+        cache,
+        'custom_access',
+        'custom_refresh',
+      );
+
+      await defaultStorage.setAccessToken('default-access');
+      await customStorage.setAccessToken('custom-access');
+
+      const defaultToken = await defaultStorage.getAccessToken();
+      const customToken = await customStorage.getAccessToken();
+
+      expect(defaultToken).toBe('default-access');
+      expect(customToken).toBe('custom-access');
+    });
+
+    it('should clear tokens independently with custom keys', async () => {
+      const defaultStorage = new CacheTokenStorage(cache);
+      const customStorage = new CacheTokenStorage(
+        cache,
+        'custom_access',
+        'custom_refresh',
+      );
+
+      await defaultStorage.setAccessToken('default-access');
+      await customStorage.setAccessToken('custom-access');
+
+      await defaultStorage.clearTokens();
+
+      const defaultToken = await defaultStorage.getAccessToken();
+      const customToken = await customStorage.getAccessToken();
+
+      expect(defaultToken).toBeNull();
+      expect(customToken).toBe('custom-access');
+    });
+  });
+
+  describe('integration with real cache', () => {
+    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);
+
+      await storage1.setAccessToken('token-1');
+      await storage2.setAccessToken('token-2');
+
+      const token1 = await storage1.getAccessToken();
+      const token2 = await storage2.getAccessToken();
+
+      expect(token1).toBe('token-1');
+      expect(token2).toBe('token-2');
+    });
+
+    it('should maintain token state across operations', async () => {
+      await storage.setAccessToken('initial-access');
+      await storage.setRefreshToken('initial-refresh');
+
+      let accessToken = await storage.getAccessToken();
+      let refreshToken = await storage.getRefreshToken();
+
+      expect(accessToken).toBe('initial-access');
+      expect(refreshToken).toBe('initial-refresh');
+
+      await storage.setAccessToken('updated-access');
+
+      accessToken = await storage.getAccessToken();
+      refreshToken = await storage.getRefreshToken();
+
+      expect(accessToken).toBe('updated-access');
+      expect(refreshToken).toBe('initial-refresh');
+    });
+  });
+});