@temboplus/afloat 0.1.77-beta.9 → 0.1.79

package/dist/lib/error/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./error.api.js";
-export * from "./error.permission.js";
-export * from "./error.utils.js";

package/dist/lib/query/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./query.builder.js";
-export * from "./query.types.js";
-export * from "./pagination/pagination.schemas.js";
-export * from "./pagination/pagination.js";

package/dist/lib/query/pagination/pagination.d.ts

@@ -1,73 +0,0 @@
-/** Serialized pagination metadata for API responses */
-export type PaginationJson = {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-    hasNext: boolean;
-    hasPrev: boolean;
-};
-/**
- * Represents pagination metadata for paginated API responses.
- * Provides computed properties for navigation and page calculations.
- */
-export declare class Pagination {
-    readonly page: number;
-    readonly limit: number;
-    readonly total: number;
-    /**
-     * @param page - Current page number (1-based)
-     * @param limit - Number of items per page
-     * @param total - Total number of items across all pages
-     */
-    constructor(page: number, limit: number, total: number);
-    /** Total number of pages */
-    get totalPages(): number;
-    /** Whether there is a next page available */
-    get hasNext(): boolean;
-    /** Whether there is a previous page available */
-    get hasPrev(): boolean;
-    /** Offset for database queries (0-based) */
-    get offset(): number;
-    /** Whether this is the first page */
-    get isFirstPage(): boolean;
-    /** Whether this is the last page */
-    get isLastPage(): boolean;
-    /**
-     * Creates a Pagination instance for the next page.
-     * @returns New Pagination instance or null if no next page exists
-     */
-    nextPage(): Pagination | null;
-    /**
-     * Creates a Pagination instance for the previous page.
-     * @returns New Pagination instance or null if no previous page exists
-     */
-    prevPage(): Pagination | null;
-    /** Converts to a plain object for JSON serialization */
-    toJSON(): {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasNext: boolean;
-        hasPrev: boolean;
-    };
-}
-/** Generic paginated response structure */
-export interface Paged<T> {
-    results: T[];
-    pagination: Pagination;
-}
-/** Type for paginated responses after JSON serialization */
-export type PaginatedApiResponse<T> = {
-    results: T[];
-    pagination: PaginationJson;
-};
-/**
- * Creates a paginated response from query results.
- */
-export declare function createPaginatedResponse<T>(results: T[], page: number, limit: number, total: number): Paged<T>;
-/**
- * Creates an empty paginated response.
- */
-export declare function emptyPaginatedResponse<T>(page?: number, limit?: number): Paged<T>;

package/dist/lib/query/pagination/pagination.schemas.d.ts

@@ -1,83 +0,0 @@
-import { z } from "zod";
-/** Zod schema for validating pagination query parameters */
-export declare const PaginationParamsSchema: z.ZodObject<{
-    page: z.ZodDefault<z.ZodNumber>;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    page: number;
-    limit: number;
-}, {
-    page?: number | undefined;
-    limit?: number | undefined;
-}>;
-/** Zod schema for validating pagination metadata */
-export declare const PaginationSchema: z.ZodObject<{
-    page: z.ZodNumber;
-    limit: z.ZodNumber;
-    total: z.ZodNumber;
-    totalPages: z.ZodNumber;
-    hasNext: z.ZodBoolean;
-    hasPrev: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-    hasNext: boolean;
-    hasPrev: boolean;
-}, {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-    hasNext: boolean;
-    hasPrev: boolean;
-}>;
-/**
- * Creates a Zod schema for a paginated response with typed results.
- */
-export declare function createPaginatedResponseSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
-    results: z.ZodArray<T, "many">;
-    pagination: z.ZodObject<{
-        page: z.ZodNumber;
-        limit: z.ZodNumber;
-        total: z.ZodNumber;
-        totalPages: z.ZodNumber;
-        hasNext: z.ZodBoolean;
-        hasPrev: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasNext: boolean;
-        hasPrev: boolean;
-    }, {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasNext: boolean;
-        hasPrev: boolean;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    results: T["_output"][];
-    pagination: {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasNext: boolean;
-        hasPrev: boolean;
-    };
-}, {
-    results: T["_input"][];
-    pagination: {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasNext: boolean;
-        hasPrev: boolean;
-    };
-}>;

package/dist/lib/query/query.builder.d.ts

@@ -1,71 +0,0 @@
-import { FilterCriteria, QueryOptions, SortCriteria, SortDirection } from "./query.types.js";
-export declare const QUERY_BUILDER_TYPE: unique symbol;
-export declare class QueryBuilder {
-    readonly options: QueryOptions;
-    constructor(options?: QueryOptions);
-    /**
-     * Type tag to identify QueryBuilder instances
-     */
-    [QUERY_BUILDER_TYPE]: string;
-    /**
-     * Safely check if an object is a QueryBuilder instance
-     */
-    static is(obj: any): obj is QueryBuilder;
-    addFilter(criteria: FilterCriteria): this;
-    where(field: string, value: any): this;
-    whereNot(field: string, value: any): this;
-    whereLike(field: string, value: string): this;
-    whereLikeLower(field: string, value: string): this;
-    whereContains(field: string, value: string): this;
-    whereStartsWith(field: string, value: string): this;
-    whereEndsWith(field: string, value: string): this;
-    whereIn(field: string, values: any[]): this;
-    whereNull(field: string): this;
-    whereNotNull(field: string): this;
-    whereGreaterThan(field: string, value: any): this;
-    whereGreaterThanOrEqual(field: string, value: any): this;
-    whereLessThan(field: string, value: any): this;
-    whereLessThanOrEqual(field: string, value: any): this;
-    whereBetween(field: string, min: any, max: any): this;
-    whereDateBetween(startDate?: string | null, endDate?: string | null): this;
-    addSort(criteria: SortCriteria): this;
-    orderBy(field: string, direction?: SortDirection): this;
-    orderByAsc(field: string): this;
-    orderByDesc(field: string): this;
-    paginate(page: number, limit: number): this;
-    /**
-     * Add eager loading for related models
-     * @param relations Relation name or array of relation names
-     */
-    with(relations: string | string[]): this;
-    /**
-     * Add a JOIN to the query to fetch related models
-     * @param relations Relation name or array of relation names to join
-     */
-    join(relations: string | string[]): this;
-    /**
-     * Add GROUP BY clause to the query
-     * @param fields Field or fields to group by
-     */
-    groupBy(fields: string | string[]): this;
-    /**
-     * Enable count mode for the query
-     * @param expression Optional count expression (defaults to '*')
-     */
-    count(expression?: string): this;
-    /**
-     * Count specific expression with alias
-     * @param expression Expression to count
-     * @param alias Alias for the count result
-     */
-    countAs(expression: string, alias: string): this;
-    /**
-     * @returns an objection-find query
-     */
-    build(): Record<string, any>;
-    /**
-     * Create a clone of this query builder
-     */
-    clone(): this;
-    static create<T extends QueryOptions>(options?: T): QueryBuilder;
-}

package/dist/lib/query/query.types.d.ts

@@ -1,36 +0,0 @@
-export declare enum FilterOperator {
-    EQUALS = "eq",
-    NOT_EQUALS = "neq",
-    LESS_THAN = "lt",
-    LESS_THAN_OR_EQUAL = "lte",
-    GREATER_THAN = "gt",
-    GREATER_THAN_OR_EQUAL = "gte",
-    LIKE = "like",
-    LIKE_LOWER = "likeLower",
-    IS_NULL = "isNull",
-    IS_NOT_NULL = "isNotNull",
-    IN = "in"
-}
-export declare enum SortDirection {
-    ASC = "asc",
-    DESC = "desc"
-}
-export interface FilterCriteria {
-    field: string;
-    operator: FilterOperator;
-    value?: any;
-}
-export interface SortCriteria {
-    field: string;
-    direction: SortDirection;
-}
-export interface QueryOptions {
-    page?: number;
-    limit?: number;
-    filters?: FilterCriteria[];
-    sort?: SortCriteria[];
-    includes?: string[];
-    join?: string[];
-    groupBy?: string[];
-    count?: string;
-}

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

@@ -1,249 +0,0 @@
-import { Permission } from "@/modules/login/permission.type.js";
-import { User } from "@/modules/auth/user.model.js";
-/**
- * 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/modules/auth/auth.repository.d.ts

@@ -1,83 +0,0 @@
-import { BaseRepository } from "@/lib/api/base-repository.js";
-import { User } from "@/modules/auth/user.model.js";
-import { authContract } from "./auth.contract.js";
-/**
- * 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>;
-    /**
-     * 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[]>;
-}