@temboplus/afloat 0.1.57 → 0.1.59

package/dist/features/admin/admin.repository.d.ts

@@ -1,179 +0,0 @@
-import { BaseRepository } from "@/lib/api";
-import { userManagementContract } from "./admin.contract";
-import type { CreateUserRequestDTO, CreateUserResponseDTO, ManagedUserQueryParamsDTO, ResetPasswordRequestDTO, UpdateUserRequestDTO } from "./admin.dtos";
-import { Role } from "@/models/role.model";
-import { ManagedUser } from "@/models/managed-user.model";
-/**
- * Repository class for managing user accounts through API interactions.
- * Handles user creation, updates, archiving, and role management.
- *
- * This repository handles pure API communication without permission checking.
- * Permission validation should be handled at the service layer or route handlers.
- *
- * @extends {BaseRepository<typeof userManagementContract>}
- *
- * @example
- * ```typescript
- * const repo = new UserManagementRepository({ token: adminToken });
- * const users = await repo.getAllUsers();
- * ```
- */
-export declare class UserManagementRepository extends BaseRepository<typeof userManagementContract> {
-    /**
-     * Creates an instance of UserManagementRepository using the user management contract.
-     *
-     * @param options - Optional configuration
-     * @param options.token - Authentication token for API calls
-     * @param options.root - Custom API root URL
-     *
-     * @example
-     * ```typescript
-     * const repo = new UserManagementRepository({
-     *   token: "admin-auth-token",
-     *   root: "https://api-staging.afloat.money/v1"
-     * });
-     * ```
-     */
-    constructor(options?: {
-        token?: string;
-        root?: string;
-    });
-    /**
-     * Creates a new user account.
-     *
-     * @param input - The data required to create a new user account
-     * @returns Promise that resolves to the newly created user response
-     * @throws {APIError} If the creation operation fails
-     *
-     * @example
-     * ```typescript
-     * const newUser = await repo.createUser({
-     *   email: "newuser@example.com",
-     *   name: "New User",
-     *   roleId: "role-id"
-     * });
-     * ```
-     */
-    createUser(input: CreateUserRequestDTO): Promise<CreateUserResponseDTO>;
-    /**
-     * Updates an existing user account by ID.
-     *
-     * @param id - The unique identifier of the user account to update
-     * @param input - The data to update the user account with
-     * @returns Promise that resolves to the updated user account
-     * @throws {APIError} If the update operation fails
-     *
-     * @example
-     * ```typescript
-     * const updatedUser = await repo.updateUser("user-id", {
-     *   name: "Updated Name",
-     *   email: "updated@example.com"
-     * });
-     * ```
-     */
-    updateUser(id: string, input: UpdateUserRequestDTO): Promise<ManagedUser>;
-    /**
-     * Archives (soft deletes) a user account by ID.
-     *
-     * @param id - The unique identifier of the user account to archive
-     * @returns Promise that resolves to the updated user object
-     * @throws {APIError} If the archive operation fails
-     *
-     * @example
-     * ```typescript
-     * const archivedUser = await repo.archiveUser("user-id");
-     * ```
-     */
-    archiveUser(id: string): Promise<ManagedUser>;
-    /**
-     * Unarchives a previously archived user account by ID.
-     *
-     * @param id - The unique identifier of the user account to unarchive
-     * @returns Promise that resolves to the updated user object
-     * @throws {APIError} If the unarchive operation fails
-     *
-     * @example
-     * ```typescript
-     * const restoredUser = await repo.unArchiveUser("user-id");
-     * ```
-     */
-    unArchiveUser(id: string): Promise<ManagedUser>;
-    /**
-     * Resets a user's password.
-     *
-     * @param id - The unique identifier of the user account
-     * @param input - Optional password reset configuration
-     * @returns Promise that resolves to success status
-     * @throws {APIError} If the password reset operation fails
-     *
-     * @example
-     * ```typescript
-     * const result = await repo.resetUserPassword("user-id", {
-     *   sendEmail: true
-     * });
-     * ```
-     */
-    resetUserPassword(id: string, input?: ResetPasswordRequestDTO): Promise<{
-        success: boolean;
-    }>;
-    /**
-     * Retrieves all user accounts.
-     * Results are ordered in descending order by creation date by default.
-     *
-     * @param query - Optional query parameters for filtering and eager loading
-     * @returns Promise that resolves to an array of managed users
-     * @throws {APIError} If the fetch operation fails
-     *
-     * @example
-     * ```typescript
-     * // Get all users with role information
-     * const users = await repo.getAllUsers({ eager: "role" });
-     *
-     * // Get users with custom query
-     * const activeUsers = await repo.getAllUsers({ status: "active" });
-     * ```
-     */
-    getAllUsers(query?: ManagedUserQueryParamsDTO): Promise<ManagedUser[]>;
-    /**
-     * Retrieves a specific user account by ID.
-     *
-     * @param id - The unique identifier of the user account to retrieve
-     * @param query - Optional query parameters for eager loading
-     * @returns Promise that resolves to the managed user
-     * @throws {APIError} If the user is not found or fetch operation fails
-     *
-     * @example
-     * ```typescript
-     * const user = await repo.getUser("user-id", { eager: "role" });
-     * console.log(`User: ${user.name}, Role: ${user.role?.name}`);
-     * ```
-     */
-    getUser(id: string, query?: ManagedUserQueryParamsDTO): Promise<ManagedUser>;
-    /**
-     * Retrieves all available roles in the system.
-     *
-     * @returns Promise that resolves to an array of roles
-     * @throws {APIError} If the fetch operation fails
-     *
-     * @example
-     * ```typescript
-     * const roles = await repo.getAllRoles();
-     * roles.forEach(role => console.log(`Role: ${role.name}`));
-     * ```
-     */
-    getAllRoles(): Promise<Role[]>;
-    /**
-     * Retrieves a specific role by ID.
-     *
-     * @param id - The unique identifier of the role to retrieve
-     * @returns Promise that resolves to the role
-     * @throws {APIError} If the role is not found or fetch operation fails
-     *
-     * @example
-     * ```typescript
-     * const role = await repo.getRole("role-id");
-     * console.log(`Role: ${role.name}, Permissions: ${role.permissions.length}`);
-     * ```
-     */
-    getRole(id: string): Promise<Role>;
-}

package/dist/features/admin/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./admin.repository";
-export * from "./admin.dtos";

package/dist/features/auth/access/access.repository.d.ts

@@ -1,55 +0,0 @@
-import { BaseRepository } from "@/lib/api/base-repository";
-import { accessContract } from "./access.api-contract";
-/**
- * Repository class for managing access-related operations.
- * Handles retrieving user access lists and permissions from the API.
- *
- * This repository handles pure API communication without permission checking.
- * Permission validation should be handled at the service layer or route handlers.
- *
- * @extends {BaseRepository<typeof accessContract>}
- *
- * @example
- * ```typescript
- * const repo = new AccessRepository({ token: userToken });
- * const accessList = await repo.getAccessList();
- * ```
- */
-export declare class AccessRepository extends BaseRepository<typeof accessContract> {
-    /**
-     * Creates an instance of AccessRepository.
-     *
-     * @param options - Optional configuration
-     * @param options.token - Authentication token for API calls
-     * @param options.root - Custom API root URL
-     *
-     * @example
-     * ```typescript
-     * const repo = new AccessRepository({
-     *   token: "user-auth-token",
-     *   root: "base-api-url"
-     * });
-     * ```
-     */
-    constructor(options?: {
-        token?: string;
-        root?: string;
-    });
-    /**
-     * Retrieves the current user's access list.
-     *
-     * @returns Promise that resolves to an array of access permissions/roles
-     * @throws {APIError} If the request fails or returns an unexpected status
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   const accessList = await repo.getAccessList();
-     *   console.log("User has access to:", accessList);
-     * } catch (error) {
-     *   console.error("Failed to get access list:", error.message);
-     * }
-     * ```
-     */
-    getAccessList(): Promise<string[]>;
-}

package/dist/features/auth/auth.manager.d.ts

@@ -1,249 +0,0 @@
-import { User } from "@/models/user.model";
-import { Permission } from "@/models/permission";
-/**
- * Clean authentication manager for client-side usage only.
- *
- * This class provides a centralized way to manage user authentication state,
- * including login, logout, and permission checking. It uses a singleton pattern
- * for client-side usage and directly interfaces with the unified auth store.
- *
- * **Architecture:**
- * - **Client-side**: Use the singleton instance via `AfloatAuth.instance`
- * - **Server-side**: Pass tokens directly to repositories (no auth manager needed)
- *
- * **Features:**
- * - Direct integration with unified auth store
- * - React hooks for reactive UI updates
- * - Permission checking utilities
- * - Automatic wallet session management
- *
- * @example
- * ```typescript
- * // Client-side usage
- * const auth = AfloatAuth.instance;
- * const user = await auth.logIn(email, password);
- *
- * // Server-side usage (no auth manager needed)
- * const walletRepo = new WalletRepository({ token: extractedToken });
- * const balance = await walletRepo.getBalance({ wallet });
- * ```
- */
-export declare class AfloatAuth {
-    /** Client-side singleton instance */
-    private static _instance;
-    /**
-     * Private constructor to control instantiation.
-     * Use the static instance getter instead.
-     *
-     * @private
-     */
-    private constructor();
-    /**
-     * Gets or creates the client-side singleton instance.
-     *
-     * @returns The client-side singleton instance
-     *
-     * @example
-     * ```typescript
-     * const auth = AfloatAuth.instance;
-     * if (auth.currentUser) {
-     *   console.log("User is logged in");
-     * }
-     * ```
-     */
-    static get instance(): AfloatAuth;
-    /**
-     * Gets the authentication repository for API operations.
-     *
-     * @private
-     * @returns The auth repository instance with current token
-     */
-    private get repo();
-    /**
-     * Gets the current authentication token.
-     *
-     * @returns The current authentication token, or undefined if not authenticated
-     *
-     * @example
-     * ```typescript
-     * const token = auth.getUserToken();
-     * if (token) {
-     *   const apiClient = new SomeRepository({ token });
-     * }
-     * ```
-     */
-    getUserToken(): string | undefined;
-    /**
-     * Gets the currently authenticated user.
-     *
-     * @returns The current user instance, or undefined if not authenticated
-     *
-     * @example
-     * ```typescript
-     * const user = auth.currentUser;
-     * if (user) {
-     *   console.log(`Welcome, ${user.name}!`);
-     * }
-     * ```
-     */
-    get currentUser(): User | undefined;
-    /**
-     * Checks if a user is currently authenticated.
-     *
-     * @returns True if user is authenticated, false otherwise
-     *
-     * @example
-     * ```typescript
-     * if (auth.isAuthenticated) {
-     *   // User is logged in
-     *   showDashboard();
-     * } else {
-     *   // User needs to log in
-     *   showLoginForm();
-     * }
-     * ```
-     */
-    get isAuthenticated(): boolean;
-    /**
-     * React hook for accessing the current user in client-side components.
-     *
-     * This hook provides reactive updates when the user state changes,
-     * making it perfect for React components that need to respond to
-     * authentication state changes.
-     *
-     * @returns The current user with reactive updates, or undefined if not authenticated
-     * @throws {Error} If called in a server environment
-     *
-     * @example
-     * ```typescript
-     * function UserProfile() {
-     *   const user = AfloatAuth.instance.useCurrentUser();
-     *
-     *   if (!user) {
-     *     return <LoginForm />;
-     *   }
-     *
-     *   return <div>Hello, {user.name}!</div>;
-     * }
-     * ```
-     */
-    useCurrentUser(): User | undefined;
-    /**
-     * Checks if the current user has a specific permission.
-     *
-     * @param perm - The permission to check
-     * @returns True if the user has the permission, false otherwise
-     *
-     * @example
-     * ```typescript
-     * if (auth.checkPermission(Permission.ViewBalance)) {
-     *   // User can view wallet balance
-     *   const walletRepo = new WalletRepository({ token: auth.getUserToken() });
-     *   const balance = await walletRepo.getBalance(wallet);
-     * } else {
-     *   console.log("User doesn't have permission to view balance");
-     * }
-     * ```
-     */
-    checkPermission(perm: Permission): boolean;
-    /**
-     * Authenticates a user with email and password.
-     *
-     * On successful authentication:
-     * - Clears any existing auth data
-     * - Stores the new user and token atomically
-     * - Initializes related services (wallet manager)
-     *
-     * @param email - The user's email address
-     * @param password - The user's password
-     * @returns Promise resolving to the authenticated user
-     * @throws {Error} If authentication fails
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   const user = await auth.logIn("user@example.com", "password123");
-     *   console.log("Login successful!");
-     *   router.push("/dashboard");
-     * } catch (error) {
-     *   console.error("Login failed:", error.message);
-     *   setError("Invalid credentials");
-     * }
-     * ```
-     */
-    logIn(email: string, password: string): Promise<User>;
-    /**
-     * Updates the current user's password.
-     *
-     * @param currentPassword - The user's current password
-     * @param newPassword - The new password to set
-     * @returns Promise resolving to true if successful
-     * @throws {Error} If the password update fails or user is not authenticated
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   await auth.resetPassword("oldPassword", "newPassword123");
-     *   console.log("Password updated successfully");
-     *   showSuccessMessage("Password updated!");
-     * } catch (error) {
-     *   console.error("Password update failed:", error.message);
-     *   showErrorMessage("Failed to update password");
-     * }
-     * ```
-     */
-    resetPassword(currentPassword: string, newPassword: string): Promise<boolean>;
-    /**
-     * Logs out the current user and clears all authentication data.
-     *
-     * This method:
-     * - Clears user state from memory and storage
-     * - Removes authentication tokens
-     * - Resets related services
-     *
-     * @example
-     * ```typescript
-     * auth.logOut();
-     * router.push("/login");
-     * console.log("User logged out successfully");
-     * ```
-     */
-    logOut(): void;
-    /**
-     * Refreshes the current authentication state.
-     * Useful for clearing potentially stale data.
-     *
-     * @example
-     * ```typescript
-     * // Clear current state and force fresh authentication
-     * auth.refresh();
-     * ```
-     */
-    refresh(): void;
-    /**
-     * Gets debug information about the current authentication state.
-     * Useful for troubleshooting authentication issues.
-     *
-     * @returns Object containing authentication state information
-     *
-     * @example
-     * ```typescript
-     * const debugInfo = auth.getDebugInfo();
-     * console.log("Auth Debug Info:", debugInfo);
-     * ```
-     */
-    getDebugInfo(): {
-        hasUser: boolean;
-        hasToken: boolean;
-        isAuthenticated: boolean;
-        userName: string;
-        tokenLength: number;
-        managerInstance: string;
-    };
-    /**
-     * Clears all stored authentication data from the unified store.
-     *
-     * @private
-     */
-    private clearSavedData;
-}

package/dist/features/auth/auth.repository.d.ts

@@ -1,66 +0,0 @@
-import { BaseRepository } from "../../lib/api/base-repository";
-import { authContract } from "./auth.contract";
-import { User } from "@/models/user.model";
-/**
- * Repository class for handling authentication-related operations.
- * Provides methods for user login and password management.
- *
- * @extends {BaseRepository<typeof authContract>}
- *
- * @example
- * ```typescript
- * const authRepo = new AuthRepository();
- * const user = await authRepo.logIn("user@example.com", "password");
- * ```
- */
-export declare class AuthRepository extends BaseRepository<typeof authContract> {
-    /**
-     * Creates an instance of AuthRepository.
-     *
-     * @param options - Optional configuration
-     * @param options.root - Custom API root URL
-     * @param options.token - Authentication token for password operations
-     */
-    constructor(options?: {
-        root?: string;
-        token?: string;
-    });
-    /**
-     * Authenticates a user with the provided email and password.
-     *
-     * @param email - The email of the user attempting to log in
-     * @param password - The password of the user
-     * @returns Promise that resolves to a User object on successful login
-     * @throws {APIError} If the email or password is invalid, or if another error occurs during login
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   const user = await authRepo.logIn("user@example.com", "securePassword");
-     *   console.log(`Welcome ${user.name}!`);
-     * } catch (error) {
-     *   console.error("Login failed:", error.message);
-     * }
-     * ```
-     */
-    logIn(email: string, password: string): Promise<User>;
-    /**
-     * Updates the current user's password.
-     *
-     * @param currentPassword - The user's current password
-     * @param newPassword - The new password the user wants to set
-     * @returns Promise that resolves to true if the password update is successful
-     * @throws {APIError} If the current password is invalid or another error occurs during the update
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   await authRepo.updatePassword("oldPassword", "newSecurePassword");
-     *   console.log("Password updated successfully");
-     * } catch (error) {
-     *   console.error("Password update failed:", error.message);
-     * }
-     * ```
-     */
-    updatePassword(currentPassword: string, newPassword: string): Promise<boolean>;
-}

package/dist/features/auth/auth.store.d.ts

@@ -1,139 +0,0 @@
-import { type StoreApi, type UseBoundStore } from "zustand";
-import { User } from "@/models/user.model";
-/** Type definition for the store's internal state */
-type AuthState = {
-    user: string | undefined;
-    token: string | undefined;
-};
-/** Type definition for the store's actions */
-interface AuthActions {
-    setUser: (user: User) => void;
-    getUser: () => User | undefined;
-    setToken: (token: string) => void;
-    getToken: () => string | undefined;
-    setUserAndToken: (user: User, token: string) => void;
-    clearAuth: () => void;
-}
-/**
- * Unified Zustand store for managing both user and token state with persistence.
- *
- * Features:
- * - Persists both user data and token to sessionStorage
- * - Serializes/deserializes User objects to/from JSON
- * - Provides reactive state updates for React components
- * - Automatically syncs user and token state
- * - Server-side rendering safe
- */
-export declare const authStore: UseBoundStore<StoreApi<AuthState & AuthActions>>;
-/**
- * Gets the current authenticated user from the auth store.
- * This function can be called from anywhere in the application.
- *
- * @returns The current user or undefined if not authenticated
- *
- * @example
- * ```typescript
- * // In BaseRepository or any other file
- * const user = getCurrentUser();
- * if (user) {
- *   console.log(`Current user: ${user.name}`);
- * }
- * ```
- */
-export declare const getCurrentUser: () => User | undefined;
-/**
- * Gets the current authentication token from the auth store.
- * This function can be called from anywhere in the application,
- * including BaseRepository for automatic token injection.
- *
- * @returns The current token or undefined if not authenticated
- *
- * @example
- * ```typescript
- * // In BaseRepository
- * const token = getCurrentToken();
- * if (token) {
- *   // Use token for API calls
- *   return initClient(contract, { baseHeaders: { token } });
- * }
- * ```
- */
-export declare const getCurrentToken: () => string | undefined;
-/**
- * React hook to access the current user with reactive updates.
- *
- * @returns The current user or undefined if not authenticated
- * @throws {Error} If called in a server environment
- *
- * @example
- * ```typescript
- * function UserProfile() {
- *   const user = useCurrentUser();
- *
- *   if (!user) {
- *     return <div>Please log in</div>;
- *   }
- *
- *   return <div>Welcome, {user.name}!</div>;
- * }
- * ```
- */
-export declare const useCurrentUser: () => User | undefined;
-/**
- * React hook to access the current token with reactive updates.
- *
- * @returns The current token or undefined if not authenticated
- * @throws {Error} If called in a server environment
- *
- * @example
- * ```typescript
- * function SomeComponent() {
- *   const token = useCurrentToken();
- *
- *   if (!token) {
- *     return <div>Please log in</div>;
- *   }
- *
- *   // Use token...
- * }
- * ```
- */
-export declare const useCurrentToken: () => string | undefined;
-/**
- * Checks if a user is currently authenticated.
- *
- * @returns True if user is authenticated, false otherwise
- *
- * @example
- * ```typescript
- * if (isAuthenticated()) {
- *   // User is logged in
- *   showDashboard();
- * } else {
- *   // User needs to log in
- *   showLoginForm();
- * }
- * ```
- */
-export declare const isAuthenticated: () => boolean;
-/**
- * Gets debug information about the current authentication state.
- * Useful for troubleshooting authentication issues.
- *
- * @returns Object containing authentication state information
- *
- * @example
- * ```typescript
- * const debugInfo = getAuthDebugInfo();
- * console.log("Auth Debug Info:", debugInfo);
- * ```
- */
-export declare const getAuthDebugInfo: () => {
-    hasUser: boolean;
-    hasToken: boolean;
-    isAuthenticated: boolean;
-    userName: string;
-    tokenLength: number;
-    storeState: string | (AuthState & AuthActions);
-};
-export {};