@k3-universe/react-kit 0.0.27 → 0.0.29

package/src/kit/builder/auth/storage.ts

@@ -0,0 +1,366 @@
+import type { AuthStorage, StorageOptions } from './types';
+
+const isBrowser =
+  typeof window !== 'undefined' && typeof window.localStorage !== 'undefined';
+
+// ============================================================================
+// Memory Storage
+// ============================================================================
+
+export const createMemoryStorage = <T>(): AuthStorage<T> => {
+  let value: T | null = null;
+
+  return {
+    get: () => value,
+    set: (next) => {
+      value = next;
+    },
+    clear: () => {
+      value = null;
+    },
+  };
+};
+
+// ============================================================================
+// Encryption Utilities
+// ============================================================================
+
+/**
+ * Simple encryption/decryption using browser's subtle crypto
+ * For production, consider using a more robust encryption library
+ */
+class SimpleEncryption {
+  private key: string;
+
+  constructor(key: string) {
+    this.key = key;
+  }
+
+  async encrypt(text: string): Promise<string> {
+    if (!crypto?.subtle) {
+      console.warn(
+        '[auth2][storage] Crypto API not available, storing unencrypted',
+      );
+      return text;
+    }
+
+    try {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(text);
+      const keyData = encoder.encode(this.key.padEnd(32, '0').slice(0, 32));
+
+      const cryptoKey = await crypto.subtle.importKey(
+        'raw',
+        keyData,
+        { name: 'AES-GCM', length: 256 },
+        false,
+        ['encrypt'],
+      );
+
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const encrypted = await crypto.subtle.encrypt(
+        { name: 'AES-GCM', iv },
+        cryptoKey,
+        data,
+      );
+
+      const result = new Uint8Array(iv.length + encrypted.byteLength);
+      result.set(iv, 0);
+      result.set(new Uint8Array(encrypted), iv.length);
+
+      return btoa(String.fromCharCode(...result));
+    } catch (error) {
+      console.error('[auth2][storage] Encryption failed:', error);
+      return text;
+    }
+  }
+
+  async decrypt(encrypted: string): Promise<string> {
+    if (!crypto?.subtle) {
+      console.warn(
+        '[auth2][storage] Crypto API not available, reading unencrypted',
+      );
+      return encrypted;
+    }
+
+    try {
+      const encoder = new TextEncoder();
+      const decoder = new TextDecoder();
+      const keyData = encoder.encode(this.key.padEnd(32, '0').slice(0, 32));
+
+      const cryptoKey = await crypto.subtle.importKey(
+        'raw',
+        keyData,
+        { name: 'AES-GCM', length: 256 },
+        false,
+        ['decrypt'],
+      );
+
+      const data = Uint8Array.from(atob(encrypted), (c) => c.charCodeAt(0));
+      const iv = data.slice(0, 12);
+      const encryptedData = data.slice(12);
+
+      const decrypted = await crypto.subtle.decrypt(
+        { name: 'AES-GCM', iv },
+        cryptoKey,
+        encryptedData,
+      );
+
+      return decoder.decode(decrypted);
+    } catch (error) {
+      console.error('[auth2][storage] Decryption failed:', error);
+      return encrypted;
+    }
+  }
+}
+
+// ============================================================================
+// Cookie Storage
+// ============================================================================
+
+export const createCookieStorage = <T>(
+  options: StorageOptions,
+): AuthStorage<T> => {
+  const key = options.key ?? 'auth2_session';
+  const cookieOpts = options.cookieOptions ?? {};
+  const fallback = createMemoryStorage<T>();
+  const encryption =
+    options.encrypt && options.encryptionKey
+      ? new SimpleEncryption(options.encryptionKey)
+      : null;
+  const cookieSetter =
+    typeof Document !== 'undefined'
+      ? Object.getOwnPropertyDescriptor(Document.prototype, 'cookie')?.set
+      : undefined;
+
+  const assignCookie = (value: string) => {
+    if (!isBrowser || typeof document === 'undefined') return;
+    if (cookieSetter) {
+      cookieSetter.call(document, value);
+      return;
+    }
+    Reflect.set(document, 'cookie', value);
+  };
+
+  const serialize = async (value: T | null): Promise<string | null> => {
+    if (value === null) return null;
+    const json = JSON.stringify(value);
+    return encryption ? await encryption.encrypt(json) : json;
+  };
+
+  const deserialize = async (value: string | null): Promise<T | null> => {
+    if (!value) return null;
+    try {
+      const decrypted = encryption ? await encryption.decrypt(value) : value;
+      return JSON.parse(decrypted) as T;
+    } catch {
+      return null;
+    }
+  };
+
+  const getCookie = (name: string): string | null => {
+    if (!isBrowser) return null;
+    const matches = document.cookie.match(
+      new RegExp(
+        `(?:^|; )${name.replace(/([.$?*|{}()[\]\\/+^])/g, '\\$1')}=([^;]*)`,
+      ),
+    );
+    return matches ? decodeURIComponent(matches[1]) : null;
+  };
+
+  const setCookie = (
+    name: string,
+    value: string,
+    opts: typeof cookieOpts = {},
+  ) => {
+    if (!isBrowser) return;
+
+    let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+
+    if (opts.maxAge) cookie += `; max-age=${opts.maxAge}`;
+    if (opts.domain) cookie += `; domain=${opts.domain}`;
+    if (opts.path !== undefined) cookie += `; path=${opts.path}`;
+    else cookie += '; path=/';
+    if (opts.secure) cookie += '; secure';
+    if (opts.sameSite) cookie += `; samesite=${opts.sameSite}`;
+
+    assignCookie(cookie);
+  };
+
+  const deleteCookie = (name: string) => {
+    if (!isBrowser) return;
+    assignCookie(`${name}=; max-age=0; path=/`);
+  };
+
+  return {
+    get: async () => {
+      try {
+        const raw = getCookie(key);
+        const value = await deserialize(raw);
+        fallback.set(value);
+        return value;
+      } catch (error) {
+        console.warn('[auth2][storage] Failed to read from cookie', error);
+        return fallback.get();
+      }
+    },
+    set: async (value) => {
+      try {
+        const serialized = await serialize(value);
+        if (serialized === null) {
+          deleteCookie(key);
+        } else {
+          setCookie(key, serialized, cookieOpts);
+        }
+        fallback.set(value);
+      } catch (error) {
+        console.warn('[auth2][storage] Failed to write to cookie', error);
+        fallback.set(value);
+      }
+    },
+    clear: () => {
+      try {
+        deleteCookie(key);
+      } catch (error) {
+        console.warn('[auth2][storage] Failed to clear cookie', error);
+      } finally {
+        fallback.clear();
+      }
+    },
+  };
+};
+
+// ============================================================================
+// Browser Storage (localStorage/sessionStorage)
+// ============================================================================
+
+export type BrowserStorageOptions<T> = {
+  key: string;
+  serialize?: (value: T | null) => Promise<string | null> | string | null;
+  deserialize?: (value: string | null) => Promise<T | null> | T | null;
+  storage?: Storage;
+  encrypt?: boolean;
+  encryptionKey?: string;
+};
+
+export const createBrowserStorage = <T>(
+  options: BrowserStorageOptions<T>,
+): AuthStorage<T> => {
+  const fallback = createMemoryStorage<T>();
+  const targetStorage =
+    options.storage ?? (isBrowser ? window.localStorage : undefined);
+
+  const encryption =
+    options.encrypt && options.encryptionKey
+      ? new SimpleEncryption(options.encryptionKey)
+      : null;
+
+  const defaultSerialize = async (value: T | null): Promise<string | null> => {
+    if (value === null) return null;
+    const json = JSON.stringify(value);
+    return encryption ? await encryption.encrypt(json) : json;
+  };
+
+  const defaultDeserialize = async (
+    value: string | null,
+  ): Promise<T | null> => {
+    if (!value) return null;
+    try {
+      const decrypted = encryption ? await encryption.decrypt(value) : value;
+      return JSON.parse(decrypted) as T;
+    } catch {
+      return null;
+    }
+  };
+
+  const serialize = options.serialize
+    ? async (value: T | null) => {
+        const result = await options.serialize?.(value);
+        return result ?? null;
+      }
+    : defaultSerialize;
+
+  const deserialize = options.deserialize
+    ? async (value: string | null) => {
+        const result = await options.deserialize?.(value);
+        return result ?? null;
+      }
+    : defaultDeserialize;
+
+  if (!targetStorage) {
+    return fallback;
+  }
+
+  return {
+    get: async () => {
+      try {
+        const raw = targetStorage.getItem(options.key);
+        const value = await deserialize(raw);
+        fallback.set(value);
+        return value;
+      } catch (error) {
+        console.warn('[auth2][storage] Failed to read from storage', error);
+        return fallback.get();
+      }
+    },
+    set: async (value) => {
+      try {
+        const serialized = await serialize(value);
+        if (serialized === null) {
+          targetStorage.removeItem(options.key);
+        } else {
+          targetStorage.setItem(options.key, serialized);
+        }
+        fallback.set(value);
+      } catch (error) {
+        console.warn('[auth2][storage] Failed to write to storage', error);
+        fallback.set(value);
+      }
+    },
+    clear: () => {
+      try {
+        targetStorage.removeItem(options.key);
+      } catch (error) {
+        console.warn('[auth2][storage] Failed to clear storage', error);
+      } finally {
+        fallback.clear();
+      }
+    },
+  };
+};
+
+// ============================================================================
+// Factory Function
+// ============================================================================
+
+/**
+ * Creates appropriate storage based on options
+ */
+export function createStorage<T>(options: StorageOptions = {}): AuthStorage<T> {
+  const storageType = options.storage ?? 'local';
+  const key = options.key ?? 'auth2_session';
+
+  switch (storageType) {
+    case 'cookie':
+      return createCookieStorage<T>(options);
+
+    case 'session':
+      return createBrowserStorage<T>({
+        key,
+        storage: isBrowser ? window.sessionStorage : undefined,
+        encrypt: options.encrypt,
+        encryptionKey: options.encryptionKey,
+      });
+
+    case 'local':
+      return createBrowserStorage<T>({
+        key,
+        storage: isBrowser ? window.localStorage : undefined,
+        encrypt: options.encrypt,
+        encryptionKey: options.encryptionKey,
+      });
+
+    default:
+      return createMemoryStorage<T>();
+  }
+}

package/src/kit/builder/auth/token-manager.ts

@@ -0,0 +1,55 @@
+import type { TokenManager } from './types';
+
+/**
+ * Default token manager implementation
+ * Handles token expiration checks and refresh scheduling
+ */
+export function createTokenManager(config?: {
+  refreshThreshold?: number; // seconds before expiry to trigger refresh
+}): TokenManager {
+  const refreshThreshold = config?.refreshThreshold ?? 300; // default 5 minutes
+
+  const isExpired = (expiresAt?: number | null): boolean => {
+    if (!expiresAt) return false;
+    return Date.now() >= expiresAt;
+  };
+
+  const shouldRefresh = (
+    expiresAt?: number | null,
+    threshold?: number,
+  ): boolean => {
+    if (!expiresAt) return false;
+    const thresholdMs = (threshold ?? refreshThreshold) * 1000;
+    return Date.now() >= expiresAt - thresholdMs;
+  };
+
+  const getTimeUntilExpiry = (expiresAt?: number | null): number => {
+    if (!expiresAt) return Infinity;
+    const timeLeft = expiresAt - Date.now();
+    return Math.max(0, timeLeft);
+  };
+
+  const scheduleRefresh = (
+    callback: () => void,
+    expiresAt?: number | null,
+  ): (() => void) => {
+    if (!expiresAt) return () => {};
+
+    const timeUntilRefresh = expiresAt - Date.now() - refreshThreshold * 1000;
+
+    if (timeUntilRefresh <= 0) {
+      callback();
+      return () => {};
+    }
+
+    const timeoutId = setTimeout(callback, timeUntilRefresh);
+    return () => clearTimeout(timeoutId);
+  };
+
+  return {
+    isExpired,
+    shouldRefresh,
+    getTimeUntilExpiry,
+    scheduleRefresh,
+  };
+}