@k3-universe/react-kit 0.0.29 → 0.0.30

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

@@ -2,8 +2,8 @@
 // Core
 // ============================================================================
 
-export { createAuthAdapter } from './adapter';
-export { AuthProvider, useAuthContext } from './AuthProvider';
+export { createAuthAdapter } from "./utils/auth-adapter";
+export { AuthProvider, useAuthContext } from "./providers/AuthProvider";
 
 // ============================================================================
 // Storage
@@ -14,20 +14,20 @@ export {
   createMemoryStorage,
   createBrowserStorage,
   createCookieStorage,
-} from './storage';
+} from "./utils/storage";
 
 // ============================================================================
 // Utilities
 // ============================================================================
 
-export { createTokenManager } from './token-manager';
+export { createTokenManager } from "./utils/token-manager";
 export {
   expandPermissions,
   expandRoles,
   checkPermissions,
   checkRoles,
   evaluatePermissionRule,
-} from './permission-checker';
+} from "./utils/permission-checker";
 
 // ============================================================================
 // Client Adapters
@@ -39,12 +39,12 @@ export {
   createAxiosAuthInterceptor,
   createAuthFetch,
   createApolloAuthLink,
-} from './client-adapters';
+} from "./utils/client-adapters";
 
 export type {
   GraphQLClientAdapterOptions,
   RESTClientAdapterOptions,
-} from './client-adapters';
+} from "./utils/client-adapters";
 
 // ============================================================================
 // Hooks
@@ -69,21 +69,19 @@ export {
   useLogout,
   useRefresh,
   useSetSession,
-} from './hooks';
+} from "./hooks";
 
 // ============================================================================
 // Components
 // ============================================================================
 
-export {
-  RequireAuth,
-  Can,
-  withPermission,
-  ShowWhenAuthenticated,
-  ShowWhenUnauthenticated,
-  ShowWhenLoading,
-  ShowWhenError,
-} from './components';
+export { RequireAuth } from "./components/RequireAuth";
+export { Can } from "./components/Can";
+export { withPermission } from "./components/withPermission";
+export { ShowWhenAuthenticated } from "./components/ShowWhenAuthenticated";
+export { ShowWhenUnauthenticated } from "./components/ShowWhenUnauthenticated";
+export { ShowWhenLoading } from "./components/ShowWhenLoading";
+export { ShowWhenError } from "./components/ShowWhenError";
 
 // ============================================================================
 // Types
@@ -131,4 +129,4 @@ export type {
   InferRole,
   InferPermission,
   InferCredentials,
-} from './types';
+} from "./types";

package/src/kit/builder/auth/{AuthProvider.tsx → providers/AuthProvider.tsx}

@@ -6,7 +6,7 @@ import {
   useSyncExternalStore,
 } from 'react';
 import type { ReactNode } from 'react';
-import type { AuthAdapter, AuthContextValue, AuthSession } from './types';
+import type { AuthAdapter, AuthContextValue, AuthSession } from '../types';
 
 type AnyAuthContextValue = AuthContextValue<
   unknown,

package/src/kit/builder/auth/types/adapter-config.ts

@@ -0,0 +1,44 @@
+import type { AuthSession, RefreshStrategy } from './core';
+import type { PermissionHierarchy, RoleHierarchy } from './permissions';
+import type { AuthAdapterState } from './state';
+import type { AuthMiddleware } from './middleware';
+import type { TokenManager } from './token-manager';
+import type { AuthStorage } from './storage';
+
+export type AuthAdapterConfig<
+  TUser = unknown,
+  TRole extends string = string,
+  TPermission extends string = string,
+  TSession extends AuthSession<TUser, TRole, TPermission> = AuthSession<
+    TUser,
+    TRole,
+    TPermission
+  >,
+  TCredentials = unknown,
+> = {
+  storage?: AuthStorage<TSession>;
+  loadSession?: () => Promise<TSession | null>;
+  login?: (credentials: TCredentials) => Promise<TSession>;
+  logout?: (session: TSession | null) => Promise<void> | void;
+  refresh?: (session: TSession) => Promise<TSession>;
+  resolveUser?: (session: TSession | null) => TUser | null;
+  resolveRoles?: (session: TSession | null) => TRole[];
+  resolvePermissions?: (session: TSession | null) => TPermission[];
+  shouldRefresh?: (session: TSession) => boolean;
+  onStateChange?: (
+    state: AuthAdapterState<TSession, TUser, TRole, TPermission>,
+  ) => void;
+
+  refreshStrategy?: RefreshStrategy;
+  refreshThreshold?: number;
+  autoRefresh?: boolean;
+  permissionHierarchy?: PermissionHierarchy<TPermission>;
+  roleHierarchy?: RoleHierarchy<TRole>;
+  middleware?: AuthMiddleware<TSession, TUser, TRole, TPermission>[];
+  tokenManager?: TokenManager;
+  retryConfig?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    retryOn?: (error: unknown) => boolean;
+  };
+};

package/src/kit/builder/auth/types/adapter.ts

@@ -0,0 +1,132 @@
+import type { AuthSession } from './core';
+import type { PermissionPolicy, PermissionRule } from './permissions';
+import type { AuthAdapterState, AuthAdapterSubscriber } from './state';
+
+export type AuthAdapter<
+  TUser = unknown,
+  TRole extends string = string,
+  TPermission extends string = string,
+  TSession extends AuthSession<TUser, TRole, TPermission> = AuthSession<
+    TUser,
+    TRole,
+    TPermission
+  >,
+  TCredentials = unknown,
+> = {
+  getState: () => AuthAdapterState<TSession, TUser, TRole, TPermission>;
+  subscribe: (
+    listener: AuthAdapterSubscriber<TSession, TUser, TRole, TPermission>,
+  ) => () => void;
+  sync: () => Promise<AuthAdapterState<TSession, TUser, TRole, TPermission>>;
+  login?: (
+    credentials: TCredentials,
+  ) => Promise<AuthAdapterState<TSession, TUser, TRole, TPermission>>;
+  logout: () => Promise<void>;
+  refresh: () => Promise<AuthAdapterState<TSession, TUser, TRole, TPermission>>;
+  setSession: (
+    session: TSession | null,
+  ) => Promise<AuthAdapterState<TSession, TUser, TRole, TPermission>>;
+  hasRole: (
+    target: TRole | TRole[],
+    options?: { requireAll?: boolean },
+  ) => boolean;
+  hasPermission: (
+    target: TPermission | TPermission[] | PermissionPolicy<TPermission>,
+    options?: { requireAll?: boolean },
+  ) => boolean;
+  can: (rule: PermissionRule<TRole, TPermission>) => boolean;
+  getToken: () => string | null;
+  isTokenExpired: () => boolean;
+  getTimeUntilExpiry: () => number;
+  scheduleAutoRefresh?: () => () => void;
+};
+
+export type AuthContextValue<
+  TUser = unknown,
+  TRole extends string = string,
+  TPermission extends string = string,
+  TSession extends AuthSession<TUser, TRole, TPermission> = AuthSession<
+    TUser,
+    TRole,
+    TPermission
+  >,
+  TCredentials = unknown,
+> = {
+  state: AuthAdapterState<TSession, TUser, TRole, TPermission>;
+  status: AuthAdapterState<TSession, TUser, TRole, TPermission>['status'];
+  session: TSession | null;
+  user: TUser | null;
+  roles: TRole[];
+  permissions: TPermission[];
+  error?: unknown;
+  login?: (
+    credentials: TCredentials,
+  ) => Promise<AuthAdapterState<TSession, TUser, TRole, TPermission>>;
+  logout: () => Promise<void>;
+  refresh: () => Promise<AuthAdapterState<TSession, TUser, TRole, TPermission>>;
+  setSession: (
+    session: TSession | null,
+  ) => Promise<AuthAdapterState<TSession, TUser, TRole, TPermission>>;
+  hasRole: (
+    target: TRole | TRole[],
+    options?: { requireAll?: boolean },
+  ) => boolean;
+  hasPermission: (
+    target: TPermission | TPermission[] | PermissionPolicy<TPermission>,
+    options?: { requireAll?: boolean },
+  ) => boolean;
+  can: (rule: PermissionRule<TRole, TPermission>) => boolean;
+  getToken: () => string | null;
+  isTokenExpired: () => boolean;
+  getTimeUntilExpiry: () => number;
+};
+
+export type RequireAuthProps<
+  TRole extends string = string,
+  TPermission extends string = string,
+> = {
+  children: React.ReactNode;
+  fallback?: React.ReactNode;
+  loadingFallback?: React.ReactNode;
+  roles?: TRole | TRole[];
+  permissions?: TPermission | TPermission[] | PermissionPolicy<TPermission>;
+  requireAll?: boolean;
+};
+
+export type CanProps<
+  TRole extends string = string,
+  TPermission extends string = string,
+> = {
+  children: React.ReactNode;
+  fallback?: React.ReactNode;
+  roles?: TRole | TRole[];
+  permissions?: TPermission | TPermission[] | PermissionPolicy<TPermission>;
+  requireAll?: boolean;
+};
+
+export type WithPermissionOptions<
+  TRole extends string = string,
+  TPermission extends string = string,
+> = {
+  roles?: TRole | TRole[];
+  permissions?: TPermission | TPermission[] | PermissionPolicy<TPermission>;
+  requireAll?: boolean;
+};
+
+export type GraphQLAuthClient<TSession = unknown, TCredentials = unknown> = {
+  login: (credentials: TCredentials) => Promise<TSession>;
+  logout?: () => Promise<void>;
+  refresh?: (refreshToken: string) => Promise<TSession>;
+  getCurrentUser?: () => Promise<TSession>;
+};
+
+export type RESTAuthClient<TSession = unknown, TCredentials = unknown> = {
+  login: (credentials: TCredentials) => Promise<TSession>;
+  logout?: () => Promise<void>;
+  refresh?: (refreshToken: string) => Promise<TSession>;
+  getCurrentUser?: () => Promise<TSession>;
+};
+
+export type ClientAdapter<TSession = unknown, TCredentials = unknown> =
+  | GraphQLAuthClient<TSession, TCredentials>
+  | RESTAuthClient<TSession, TCredentials>;

package/src/kit/builder/auth/types/core.ts

@@ -0,0 +1,27 @@
+export type AuthStatus =
+  | 'idle'
+  | 'loading'
+  | 'authenticated'
+  | 'unauthenticated'
+  | 'error';
+
+export type TokenType = 'bearer' | 'jwt' | 'custom';
+
+export type RefreshStrategy = 'auto' | 'manual' | 'sliding';
+
+export type AuthSession<
+  TUser = unknown,
+  TRole = string,
+  TPermission = string,
+> = {
+  user?: TUser | null;
+  accessToken?: string | null;
+  refreshToken?: string | null;
+  tokenType?: TokenType;
+  roles?: TRole[] | null;
+  permissions?: TPermission[] | null;
+  expiresAt?: number | null;
+  refreshExpiresAt?: number | null;
+  issuedAt?: number | null;
+  meta?: Record<string, unknown> | null;
+};

package/src/kit/builder/auth/types/index.ts

@@ -0,0 +1,9 @@
+export * from './core';
+export * from './permissions';
+export * from './state';
+export * from './storage';
+export * from './middleware';
+export * from './token-manager';
+export * from './adapter-config';
+export * from './adapter';
+export * from './utils';

package/src/kit/builder/auth/types/middleware.ts

@@ -0,0 +1,20 @@
+import type { AuthAdapterState } from './state';
+
+export type AuthMiddleware<
+  TSession = unknown,
+  TUser = unknown,
+  TRole extends string = string,
+  TPermission extends string = string,
+> = {
+  onBeforeLogin?: (credentials: unknown) => Promise<void> | void;
+  onAfterLogin?: (
+    state: AuthAdapterState<TSession, TUser, TRole, TPermission>,
+  ) => Promise<void> | void;
+  onBeforeLogout?: () => Promise<void> | void;
+  onAfterLogout?: () => Promise<void> | void;
+  onRefresh?: (
+    state: AuthAdapterState<TSession, TUser, TRole, TPermission>,
+  ) => Promise<void> | void;
+  onError?: (error: unknown) => Promise<void> | void;
+  onSessionExpired?: () => Promise<void> | void;
+};

package/src/kit/builder/auth/types/permissions.ts

@@ -0,0 +1,23 @@
+export type PermissionOperator = 'AND' | 'OR';
+
+export type PermissionPolicy<TPermission extends string = string> = {
+  operator?: PermissionOperator;
+  permissions: TPermission[];
+};
+
+export type PermissionRule<
+  TRole extends string = string,
+  TPermission extends string = string,
+> = {
+  roles?: TRole | TRole[];
+  permissions?: TPermission | TPermission[] | PermissionPolicy<TPermission>;
+  requireAll?: boolean;
+};
+
+export type PermissionHierarchy<TPermission extends string = string> = {
+  [key in TPermission]?: TPermission[];
+};
+
+export type RoleHierarchy<TRole extends string = string> = {
+  [key in TRole]?: TRole[];
+};

package/src/kit/builder/auth/types/state.ts

@@ -0,0 +1,16 @@
+import type { AuthStatus } from './core';
+
+export type AuthAdapterState<TSession, TUser, TRole, TPermission> = {
+  status: AuthStatus;
+  session: TSession | null;
+  user: TUser | null;
+  roles: TRole[];
+  permissions: TPermission[];
+  error?: unknown;
+  lastRefresh?: number;
+  tokenExpiresIn?: number;
+};
+
+export type AuthAdapterSubscriber<TSession, TUser, TRole, TPermission> = (
+  state: AuthAdapterState<TSession, TUser, TRole, TPermission>,
+) => void;

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

@@ -0,0 +1,21 @@
+export type AuthStorage<TSession> = {
+  get: () => Promise<TSession | null> | TSession | null;
+  set: (value: TSession | null) => Promise<void> | void;
+  clear: () => Promise<void> | void;
+};
+
+export type StorageType = 'local' | 'session' | 'cookie' | 'memory';
+
+export type StorageOptions = {
+  key?: string;
+  encrypt?: boolean;
+  encryptionKey?: string;
+  storage?: StorageType;
+  cookieOptions?: {
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+    maxAge?: number;
+  };
+};

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

@@ -0,0 +1,9 @@
+export type TokenManager = {
+  isExpired: (expiresAt?: number | null) => boolean;
+  shouldRefresh: (expiresAt?: number | null, threshold?: number) => boolean;
+  getTimeUntilExpiry: (expiresAt?: number | null) => number;
+  scheduleRefresh?: (
+    callback: () => void,
+    expiresAt?: number | null,
+  ) => () => void;
+};

package/src/kit/builder/auth/types/utils.ts

@@ -0,0 +1,55 @@
+// ============================================================================
+// Utility Types
+// ============================================================================
+
+import type { AuthAdapter } from "./adapter";
+
+export type InferSession<T> = T extends AuthAdapter<
+  infer _User,
+  infer _Role extends string,
+  infer _Permission extends string,
+  infer TSession,
+  infer _Credentials
+>
+  ? TSession
+  : never;
+
+export type InferUser<T> = T extends AuthAdapter<
+  infer TUser,
+  infer _Role extends string,
+  infer _Permission extends string,
+  infer _Session,
+  infer _Credentials
+>
+  ? TUser
+  : never;
+
+export type InferRole<T> = T extends AuthAdapter<
+  infer _User,
+  infer TRole extends string,
+  infer _Permission extends string,
+  infer _Session,
+  infer _Credentials
+>
+  ? TRole
+  : never;
+
+export type InferPermission<T> = T extends AuthAdapter<
+  infer _User,
+  infer _Role extends string,
+  infer TPermission extends string,
+  infer _Session,
+  infer _Credentials
+>
+  ? TPermission
+  : never;
+
+export type InferCredentials<T> = T extends AuthAdapter<
+  infer _User,
+  infer _Role extends string,
+  infer _Permission extends string,
+  infer _Session,
+  infer TCredentials
+>
+  ? TCredentials
+  : never;

package/src/kit/builder/auth/{adapter.ts → utils/auth-adapter.ts}

@@ -16,7 +16,7 @@ import type {
   AuthStatus,
   PermissionPolicy,
   PermissionRule,
-} from './types';
+} from '../types';
 
 const unique = <T>(values: T[]): T[] => {
   return Array.from(new Set(values));
@@ -334,7 +334,8 @@ export function createAuthAdapter<
       return nextState;
     } catch (error) {
       await executeMiddleware('onError', error);
-      return await setSession(null, 'error', error);
+      await setSession(null, 'error', error);
+      throw error;
     }
   };
 

package/src/kit/builder/auth/utils/client-adapters/apollo-link.ts

@@ -0,0 +1,30 @@
+export function createApolloAuthLink(
+  getToken: () => string | null,
+  options?: {
+    tokenType?: string
+  },
+) {
+  const tokenType = options?.tokenType ?? 'Bearer'
+
+  // This requires @apollo/client to be installed
+  // We'll return a function that creates the link to avoid direct dependency
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return (ApolloLink: any) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new ApolloLink((operation: any, forward: any) => {
+      const token = getToken()
+
+      if (token) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        operation.setContext(({ headers = {} }: any) => ({
+          headers: {
+            ...headers,
+            authorization: `${tokenType} ${token}`,
+          },
+        }))
+      }
+
+      return forward(operation)
+    })
+  }
+}

package/src/kit/builder/auth/utils/client-adapters/axios.ts

@@ -0,0 +1,61 @@
+export function createAxiosAuthInterceptor(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  axiosInstance: any,
+  getToken: () => string | null,
+  options?: {
+    tokenType?: string
+    onTokenExpired?: () => void
+    refreshToken?: () => Promise<void>
+  },
+) {
+  const tokenType = options?.tokenType ?? 'Bearer'
+
+  // Request interceptor
+  axiosInstance.interceptors.request.use(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async (config: any) => {
+      const token = getToken()
+      if (token) {
+        config.headers.Authorization = `${tokenType} ${token}`
+      }
+      return config
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (error: any) => Promise.reject(error),
+  )
+
+  // Response interceptor for token refresh
+  if (options?.refreshToken) {
+    axiosInstance.interceptors.response.use(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (response: any) => response,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async (error: any) => {
+        const originalRequest = error.config
+
+        // If token expired and we haven't retried yet
+        if (
+          error.response?.status === 401 &&
+          !originalRequest._retry &&
+          options.refreshToken
+        ) {
+          originalRequest._retry = true
+
+          try {
+            await options.refreshToken()
+            const token = getToken()
+            if (token) {
+              originalRequest.headers.Authorization = `${tokenType} ${token}`
+            }
+            return axiosInstance(originalRequest)
+          } catch (refreshError) {
+            options.onTokenExpired?.()
+            return Promise.reject(refreshError)
+          }
+        }
+
+        return Promise.reject(error)
+      },
+    )
+  }
+}

package/src/kit/builder/auth/utils/client-adapters/fetch.ts

@@ -0,0 +1,48 @@
+export function createAuthFetch(
+  getToken: () => string | null,
+  options?: {
+    tokenType?: string
+    onTokenExpired?: () => void
+    refreshToken?: () => Promise<void>
+  },
+): typeof fetch {
+  const tokenType = options?.tokenType ?? 'Bearer'
+
+  return async (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    const token = getToken()
+    const headers = new Headers(init?.headers)
+
+    if (token) {
+      headers.set('Authorization', `${tokenType} ${token}`)
+    }
+
+    const response = await fetch(input, {
+      ...init,
+      headers,
+    })
+
+    // Handle token expiration
+    if (response.status === 401 && options?.refreshToken) {
+      try {
+        await options.refreshToken()
+        const newToken = getToken()
+
+        if (newToken) {
+          headers.set('Authorization', `${tokenType} ${newToken}`)
+          return await fetch(input, {
+            ...init,
+            headers,
+          })
+        }
+      } catch (error) {
+        options.onTokenExpired?.()
+        throw error
+      }
+    }
+
+    return response
+  }
+}

package/src/kit/builder/auth/utils/client-adapters/graphql.ts

@@ -0,0 +1,60 @@
+import type { AuthAdapterConfig, AuthSession, GraphQLAuthClient } from '../../types'
+
+export type GraphQLClientAdapterOptions<
+  TUser = unknown,
+  TRole extends string = string,
+  TPermission extends string = string,
+  TSession extends AuthSession<TUser, TRole, TPermission> = AuthSession<
+    TUser,
+    TRole,
+    TPermission
+  >,
+  TCredentials = unknown,
+> = {
+  client: GraphQLAuthClient<TSession, TCredentials>
+  resolveUser?: (session: TSession | null) => TUser | null
+  resolveRoles?: (session: TSession | null) => TRole[]
+  resolvePermissions?: (session: TSession | null) => TPermission[]
+}
+
+export function createGraphQLAuthAdapter<
+  TUser = unknown,
+  TRole extends string = string,
+  TPermission extends string = string,
+  TSession extends AuthSession<TUser, TRole, TPermission> = AuthSession<
+    TUser,
+    TRole,
+    TPermission
+  >,
+  TCredentials = unknown,
+>(
+  options: GraphQLClientAdapterOptions<
+    TUser,
+    TRole,
+    TPermission,
+    TSession,
+    TCredentials
+  >,
+): Partial<
+  AuthAdapterConfig<TUser, TRole, TPermission, TSession, TCredentials>
+> {
+  return {
+    login: options.client.login,
+    logout: options.client.logout,
+    refresh: options.client.refresh
+      ? async (session: TSession) => {
+          if (!session.refreshToken) {
+            throw new Error('No refresh token available')
+          }
+          if (!options.client.refresh) {
+            throw new Error('Refresh function not provided')
+          }
+          return await options.client.refresh(session.refreshToken)
+        }
+      : undefined,
+    loadSession: options.client.getCurrentUser,
+    resolveUser: options.resolveUser,
+    resolveRoles: options.resolveRoles,
+    resolvePermissions: options.resolvePermissions,
+  }
+}