@k3-universe/react-kit 0.0.29 → 0.0.31

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

@@ -1,237 +0,0 @@
-import type {
-  AuthSession,
-  PermissionPolicy,
-  PermissionRule,
-  WithPermissionOptions,
-} from './types';
-import { useAuthContext } from './AuthProvider';
-
-// ============================================================================
-// Core Hooks
-// ============================================================================
-
-/**
- * Hook to access the entire auth context
- */
-export function useAuth() {
-  return useAuthContext();
-}
-
-/**
- * Hook to get the current auth status
- */
-export function useAuthStatus() {
-  const { status } = useAuthContext();
-  return status;
-}
-
-/**
- * Hook to check if user is authenticated
- */
-export function useIsAuthenticated() {
-  const { status } = useAuthContext();
-  return status === 'authenticated';
-}
-
-/**
- * Hook to get the current session
- */
-export function useAuthSession<TSession extends AuthSession>() {
-  const { session } = useAuthContext();
-  return session as TSession | null;
-}
-
-/**
- * Hook to get the current user
- */
-export function useAuthUser<TUser>() {
-  const { user } = useAuthContext();
-  return user as TUser | null;
-}
-
-/**
- * Hook to get user roles
- */
-export function useAuthRoles<TRole extends string = string>() {
-  const { roles } = useAuthContext();
-  return roles as TRole[];
-}
-
-/**
- * Hook to get user permissions
- */
-export function useAuthPermissions<TPermission extends string = string>() {
-  const { permissions } = useAuthContext();
-  return permissions as TPermission[];
-}
-
-/**
- * Hook to get authentication error
- */
-export function useAuthError() {
-  const { error } = useAuthContext();
-  return error;
-}
-
-// ============================================================================
-// Permission Hooks
-// ============================================================================
-
-/**
- * Hook to check if user has specific permission(s)
- * Supports permission policies with AND/OR operators
- *
- * @example
- * ```tsx
- * // Check single permission
- * const canEdit = usePermission('post:edit');
- *
- * // Check multiple permissions (all required by default)
- * const canManage = usePermission(['post:edit', 'post:delete']);
- *
- * // Check multiple permissions (any one required)
- * const canModify = usePermission(['post:edit', 'post:delete'], { requireAll: false });
- *
- * // Check with policy
- * const canAccess = usePermission({
- *   operator: 'OR',
- *   permissions: ['admin:access', 'moderator:access']
- * });
- * ```
- */
-export function usePermission<TPermission extends string = string>(
-  permission: TPermission | TPermission[] | PermissionPolicy<TPermission>,
-  options?: { requireAll?: boolean },
-) {
-  const { hasPermission } = useAuthContext();
-  return hasPermission(permission, options);
-}
-
-/**
- * Hook to check if user has specific role(s)
- *
- * @example
- * ```tsx
- * // Check single role
- * const isAdmin = useRole('admin');
- *
- * // Check multiple roles (all required by default)
- * const isSuperAdmin = useRole(['admin', 'super']);
- *
- * // Check multiple roles (any one required)
- * const isStaff = useRole(['admin', 'moderator'], { requireAll: false });
- * ```
- */
-export function useRole<TRole extends string = string>(
-  roles: TRole | TRole[],
-  options?: { requireAll?: boolean },
-) {
-  const { hasRole } = useAuthContext();
-  return hasRole(roles, options);
-}
-
-/**
- * Hook to check complex permission rules
- * Combines role and permission checks with flexible logic
- *
- * @example
- * ```tsx
- * // Check if user has admin role AND edit permission
- * const canAdminEdit = useCan({
- *   roles: 'admin',
- *   permissions: 'post:edit',
- *   requireAll: true
- * });
- *
- * // Check if user has admin role OR edit permission
- * const canAccess = useCan({
- *   roles: 'admin',
- *   permissions: 'post:edit',
- *   requireAll: false
- * });
- *
- * // Complex policy
- * const canManage = useCan({
- *   roles: ['admin', 'moderator'],
- *   permissions: {
- *     operator: 'OR',
- *     permissions: ['post:edit', 'post:delete']
- *   }
- * });
- * ```
- */
-export function useCan<
-  TRole extends string = string,
-  TPermission extends string = string,
->(
-  rule:
-    | WithPermissionOptions<TRole, TPermission>
-    | PermissionRule<TRole, TPermission>,
-) {
-  const { can } = useAuthContext();
-  return can(rule as PermissionRule<TRole, TPermission>);
-}
-
-// ============================================================================
-// Token Hooks
-// ============================================================================
-
-/**
- * Hook to get the current auth token
- */
-export function useAuthToken() {
-  const { getToken } = useAuthContext();
-  return getToken();
-}
-
-/**
- * Hook to check if token is expired
- */
-export function useIsTokenExpired() {
-  const { isTokenExpired } = useAuthContext();
-  return isTokenExpired();
-}
-
-/**
- * Hook to get time until token expiry in milliseconds
- */
-export function useTimeUntilExpiry() {
-  const { getTimeUntilExpiry } = useAuthContext();
-  return getTimeUntilExpiry();
-}
-
-// ============================================================================
-// Action Hooks
-// ============================================================================
-
-/**
- * Hook to get the login function
- */
-export function useLogin<TCredentials = unknown>() {
-  const { login } = useAuthContext();
-  return login as ((credentials: TCredentials) => Promise<unknown>) | undefined;
-}
-
-/**
- * Hook to get the logout function
- */
-export function useLogout() {
-  const { logout } = useAuthContext();
-  return logout;
-}
-
-/**
- * Hook to get the refresh function
- */
-export function useRefresh() {
-  const { refresh } = useAuthContext();
-  return refresh;
-}
-
-/**
- * Hook to get the setSession function
- */
-export function useSetSession<TSession extends AuthSession>() {
-  const { setSession } = useAuthContext();
-  return setSession as (session: TSession | null) => Promise<unknown>;
-}

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

@@ -1,366 +0,0 @@
-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>();
-  }
-}