@temboplus/afloat 0.1.60 → 0.1.62

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

@@ -0,0 +1,55 @@
+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/{esm/src/features/auth/contract.d.ts → dist/features/auth/auth.contract.d.ts}

@@ -23,13 +23,14 @@ export declare const authContract: {
             201: z.ZodObject<{
                 profile: z.ZodObject<{
                     id: z.ZodString;
-                    firstName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-                    lastName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                    firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     displayName: z.ZodString;
-                    phone: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     accountNo: z.ZodString;
-                    email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-                }, z.UnknownKeysParam, z.ZodTypeAny, {
+                    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    autoApprove: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, "strip", z.ZodTypeAny, {
                     id: string;
                     displayName: string;
                     accountNo: string;
@@ -37,6 +38,7 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
+                    autoApprove?: boolean | null | undefined;
                 }, {
                     id: string;
                     displayName: string;
@@ -45,6 +47,7 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
+                    autoApprove?: boolean | null | undefined;
                 }>;
                 token: z.ZodString;
                 access: z.ZodArray<z.ZodString, "many">;
@@ -59,6 +62,7 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
+                    autoApprove?: boolean | null | undefined;
                 };
                 token: string;
                 access: string[];
@@ -72,6 +76,7 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
+                    autoApprove?: boolean | null | undefined;
                 };
                 token: string;
                 access: string[];
@@ -99,14 +104,13 @@ export declare const authContract: {
             currentPassword: z.ZodString;
             newPassword: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            currentPassword: string;
             newPassword: string;
-        }, {
             currentPassword: string;
+        }, {
             newPassword: string;
+            currentPassword: string;
         }>;
         path: "/password";
         responses: {};
     };
 };
-//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1,249 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,139 @@
+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 {};

package/{script/npm/src/src/features/auth/identity/contract.d.ts → dist/features/auth/identity/identity.api-contract.d.ts}

@@ -20,4 +20,3 @@ export declare const identityContract: {
         };
     };
 };
-//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1,58 @@
+import { identityContract } from "./identity.api-contract";
+import type { ClientInferResponseBody } from "@ts-rest/core";
+import { BaseRepository } from "@/lib/api";
+type GetUserIdentityResponse = ClientInferResponseBody<typeof identityContract.getUserCredentials>;
+/**
+ * Repository class for retrieving user identity-related information.
+ * Handles fetching user credentials and identity data 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 identityContract>}
+ *
+ * @example
+ * ```typescript
+ * const repo = new IdentityRepository({ token: userToken });
+ * const identity = await repo.getIdentity();
+ * ```
+ */
+export declare class IdentityRepository extends BaseRepository<typeof identityContract> {
+    /**
+     * Creates an instance of IdentityRepository.
+     *
+     * @param options - Optional configuration
+     * @param options.token - Authentication token for API calls
+     * @param options.root - Custom API root URL
+     *
+     * @example
+     * ```typescript
+     * const repo = new IdentityRepository({
+     *   token: "user-auth-token",
+     *   root: "base-api-url"
+     * });
+     * ```
+     */
+    constructor(options?: {
+        token?: string;
+        root?: string;
+    });
+    /**
+     * Retrieves the current user's login credentials and identity information.
+     *
+     * @returns Promise that resolves to the user's login credentials
+     * @throws {APIError} If the request fails or returns an unexpected status
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const identity = await repo.getIdentity();
+     *   console.log("User identity:", identity);
+     * } catch (error) {
+     *   console.error("Failed to get user identity:", error.message);
+     * }
+     * ```
+     */
+    getIdentity(): Promise<GetUserIdentityResponse>;
+}
+export {};

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

@@ -0,0 +1,5 @@
+export * from "./auth.manager";
+export * from "./auth.repository";
+export * from "./access/access.repository";
+export * from "./identity/identity.repository";
+export * from "./profile/profile.repository";

package/{script/npm/src/src/features/auth/profile/contract.d.ts → dist/features/auth/profile/profile.api-contract.d.ts}

@@ -8,13 +8,14 @@ export declare const profileContract: {
         responses: {
             200: import("zod").ZodObject<{
                 id: import("zod").ZodString;
-                firstName: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
-                lastName: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+                firstName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                lastName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
                 displayName: import("zod").ZodString;
-                phone: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+                phone: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
                 accountNo: import("zod").ZodString;
-                email: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
-            }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+                email: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                autoApprove: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            }, "strip", import("zod").ZodTypeAny, {
                 id: string;
                 displayName: string;
                 accountNo: string;
@@ -22,6 +23,7 @@ export declare const profileContract: {
                 lastName?: string | null | undefined;
                 phone?: string | null | undefined;
                 email?: string | null | undefined;
+                autoApprove?: boolean | null | undefined;
             }, {
                 id: string;
                 displayName: string;
@@ -30,8 +32,8 @@ export declare const profileContract: {
                 lastName?: string | null | undefined;
                 phone?: string | null | undefined;
                 email?: string | null | undefined;
+                autoApprove?: boolean | null | undefined;
             }>;
         };
     };
 };
-//# sourceMappingURL=contract.d.ts.map