@temboplus/afloat 0.1.76-beta.0 → 0.1.77-beta.10

package/dist/modules/wallet/wallet.repository.d.ts

@@ -1,10 +1,14 @@
 import { Amount } from "@temboplus/frontend-core";
 import { WalletStatementEntry } from "./statement-entry.model.js";
 import { Wallet } from "./wallet.model.js";
-import { WalletDTOSchemas } from "./wallet.dtos.js";
-import { z } from "zod";
 import { contract } from "./wallet.contract.js";
 import { BaseRepository } from "@/lib/api/base-repository.js";
+import { WalletQuery } from "./wallet.query.js";
+import { WalletQueryDTO } from "./wallet.dtos.js";
+/**
+ * Flexible query input type - supports the class, filters interface, URL params, etc.
+ */
+export type WalletQueryInput = WalletQuery | WalletQueryDTO | Record<string, string> | URLSearchParams | null | undefined;
 /**
  * Repository class for managing wallet operations including balance checking,
  * statement generation, and wallet information retrieval.
@@ -87,13 +91,9 @@ export declare class WalletRepository extends BaseRepository<typeof contract> {
     /**
      * Retrieves all wallets associated with the authenticated user.
      *
-     * Supports optional filtering through query parameters such as accountNo,
-     * status, or currency filtering.
+     * Supports flexible filtering through WalletQuery or plain filter objects.
      *
      * @param query - Optional query parameters for filtering wallets
-     * @param query.accountNo - Filter by specific account number
-     * @param query.status - Filter by wallet status (active, inactive, etc.)
-     * @param query.currencyCode - Filter by currency code
      * @returns Promise that resolves to an array of validated Wallet instances
      * @throws {Error} If the wallet fetch operation fails or data is invalid
      *
@@ -105,14 +105,38 @@ export declare class WalletRepository extends BaseRepository<typeof contract> {
      * // Get specific wallet by account number
      * const specificWallet = await repo.getWallets({ accountNo: '123456789' });
      *
-     * // Get wallets with multiple filters
-     * const activeUSDWallets = await repo.getWallets({
-     *   status: 'active',
-     *   currencyCode: 'USD'
-     * });
+     * // Get wallets with multiple filters using WalletQuery
+     * const query = WalletQuery.create()
+     *   .whereCountryCode('TZ')
+     *   .whereCurrencyCode('TZS');
+     * const tzWallets = await repo.getWallets(query);
+     *
+     * // Get wallets with filters object
+     * const usdWallets = await repo.getWallets({ currencyCode: 'USD' });
      * ```
      */
-    getWallets(query?: z.infer<typeof WalletDTOSchemas.walletQuery>): Promise<Wallet[]>;
+    getWallets(query?: WalletQueryInput): Promise<Wallet[]>;
+    /**
+     * Retrieves a single wallet by its ID.
+     *
+     * Since the API doesn't have a dedicated /id endpoint, this method queries
+     * the list endpoint with the ID filter and returns the first result.
+     *
+     * @param id - The unique identifier of the wallet to retrieve
+     * @returns Promise that resolves to the wallet if found, undefined otherwise
+     * @throws {Error} If the fetch operation fails
+     *
+     * @example
+     * ```typescript
+     * const wallet = await repo.getByID("wallet-id");
+     * if (wallet) {
+     *   console.log(`Wallet: ${wallet.accountName}`);
+     * } else {
+     *   console.log('Wallet not found');
+     * }
+     * ```
+     */
+    getByID(id: string): Promise<Wallet | undefined>;
     /**
      * Retrieves wallet statement entries for a specified date range.
      *
@@ -170,4 +194,12 @@ export declare class WalletRepository extends BaseRepository<typeof contract> {
         wallet?: Wallet;
         accountNo?: string;
     }): Promise<WalletStatementEntry[]>;
+    /**
+     * Check if a wallet exists with the given query
+     */
+    exists(query?: WalletQueryInput): Promise<boolean>;
+    /**
+     * Get count of wallets matching a query
+     */
+    count(query?: WalletQueryInput): Promise<number>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temboplus/afloat",
-  "version": "0.1.76-beta.0",
+  "version": "0.1.77-beta.10",
   "description": "A foundational library for Temboplus-Afloat projects.",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
@@ -58,6 +58,6 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "@temboplus/frontend-core": "^0.2.19"
+    "@temboplus/frontend-core": "^0.2.20-beta.2"
   }
 }

package/dist/modules/user/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./user.repository.js";
-export * from "./user.dtos.js";
-export * from "./user.model.js";
-export * from "./role.model.js";

package/dist/modules/user/role.model.d.ts

@@ -1,13 +0,0 @@
-import { RoleDTO } from "@/modules/user/user.dtos.js";
-export declare class Role {
-    readonly id: string;
-    readonly name: string;
-    readonly description?: string;
-    readonly permissions: ReadonlySet<string>;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    constructor(data: RoleDTO);
-    hasPermission(permission: string): boolean;
-    static from(data: any): Role | undefined;
-    toJSON(): any;
-}

package/dist/modules/user/user.dtos.d.ts

@@ -1,145 +0,0 @@
-import { z } from "zod";
-/**
- * Type definition for password schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _PasswordType = z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
-/**
- * Type definition for role schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _RoleType = z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    access: z.ZodArray<z.ZodString>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}>;
-/**
- * Type definition for managed user schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _ManagedUserType = z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    identity: z.ZodString;
-    type: z.ZodString;
-    profileId: z.ZodString;
-    roleId: z.ZodString;
-    resetPassword: z.ZodBoolean;
-    isActive: z.ZodBoolean;
-    isArchived: z.ZodBoolean;
-    role: z.ZodOptional<z.ZodType<RoleDTO>>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}>;
-/**
- * Type definition for create user request schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _CreateUserRequestType = z.ZodObject<{
-    name: z.ZodString;
-    identity: z.ZodString;
-    password: z.ZodOptional<_PasswordType>;
-    roleId: z.ZodOptional<z.ZodString>;
-    resetPassword: z.ZodOptional<z.ZodBoolean>;
-}>;
-/**
- * Type definition for update user request schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _UpdateUserRequestType = z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    roleId: z.ZodOptional<z.ZodString>;
-    password: z.ZodOptional<_PasswordType>;
-    resetPassword: z.ZodOptional<z.ZodBoolean>;
-    isActive: z.ZodOptional<z.ZodBoolean>;
-}>;
-/**
- * Type definition for reset password request schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _ResetPasswordRequestType = z.ZodObject<{
-    newPassword: z.ZodOptional<_PasswordType>;
-    sendNotification: z.ZodOptional<z.ZodBoolean>;
-}>;
-/**
- * Type definition for create user response schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _CreateUserResponseType = z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    identity: z.ZodString;
-    type: z.ZodString;
-    profileId: z.ZodString;
-    roleId: z.ZodString;
-    isActive: z.ZodBoolean;
-    isArchived: z.ZodBoolean;
-    createdAt: z.ZodString;
-}>;
-/**
- * Type definition for managed user query parameters schema using Zod.
- * This is used as a TypeScript type helper for the actual schema implementation.
- */
-type _ManagedUserQueryParamsType = z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    identity: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodString>;
-    profileId: z.ZodOptional<z.ZodString>;
-    roleId: z.ZodOptional<z.ZodString>;
-    resetPassword: z.ZodOptional<z.ZodNumber>;
-    isActive: z.ZodOptional<z.ZodNumber>;
-    isArchived: z.ZodOptional<z.ZodNumber>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    updatedAt: z.ZodOptional<z.ZodString>;
-    eager: z.ZodOptional<z.ZodString>;
-}>;
-/**
- * Collection of user management schemas for export.
- * Provides access to all user and role validation schemas.
- */
-export declare const UserManagementDTOSchemas: {
-    role: _RoleType;
-    managedUser: _ManagedUserType;
-    managedUserQueryParams: _ManagedUserQueryParamsType;
-    createUserRequest: _CreateUserRequestType;
-    updateUserRequest: _UpdateUserRequestType;
-    resetPasswordRequest: _ResetPasswordRequestType;
-    createUserResponse: _CreateUserResponseType;
-    password: _PasswordType;
-};
-/**
- * TypeScript type for a validated role object.
- * Use this type for role instances that have been validated against the schema.
- */
-export type RoleDTO = z.infer<typeof UserManagementDTOSchemas.role>;
-/**
- * TypeScript type for a create user request object.
- * Use this type for user creation requests that have been validated against the schema.
- */
-export type CreateUserRequestDTO = z.infer<typeof UserManagementDTOSchemas.createUserRequest>;
-/**
- * TypeScript type for an update user request object.
- * Use this type for user update requests that have been validated against the schema.
- */
-export type UpdateUserRequestDTO = z.infer<typeof UserManagementDTOSchemas.updateUserRequest>;
-/**
- * TypeScript type for a reset password request object.
- * Use this type for password reset requests that have been validated against the schema.
- */
-export type ResetPasswordRequestDTO = z.infer<typeof UserManagementDTOSchemas.resetPasswordRequest>;
-/**
- * TypeScript type for a create user response object.
- * Use this type for user creation responses that have been validated against the schema.
- */
-export type CreateUserResponseDTO = z.infer<typeof UserManagementDTOSchemas.createUserResponse>;
-/**
- * TypeScript type for managed user query parameters.
- * Use this type for query parameter objects that have been validated against the schema.
- * All fields are optional to allow flexible filtering and searching.
- */
-export type ManagedUserQueryParamsDTO = z.infer<typeof UserManagementDTOSchemas.managedUserQueryParams>;
-export {};

package/dist/modules/user/user.model.d.ts

@@ -1,108 +0,0 @@
-import { RoleDTO } from "@/modules/user/user.dtos.js";
-import { Role } from "./role.model.js";
-export interface UserEntityData {
-    id: string;
-    name: string;
-    identity: string;
-    profileId: string;
-    permissions: string[];
-}
-/**
- * Base user entity - represents a user in the system
- */
-export declare class UserEntity {
-    readonly id: string;
-    readonly name: string;
-    readonly identity: string;
-    readonly profileId: string;
-    readonly permissions: ReadonlySet<string>;
-    constructor(data: UserEntityData);
-    /**
-     * Check if user has a specific permission
-     */
-    can(permission: string): boolean;
-    /**
-     * Check if user has any of the specified permissions
-     */
-    canAny(permissions: string[]): boolean;
-    /**
-     * Check if user has all of the specified permissions
-     */
-    canAll(permissions: string[]): boolean;
-}
-export interface AuthenticatedUserData {
-    name: string;
-    identity: string;
-    profileId: string;
-    profile: any;
-    token: string;
-    resetPassword: boolean;
-    permissions: string[];
-    sessionId?: string;
-    expiresAt?: string;
-}
-export interface ManagedUserData {
-    id: string;
-    name: string;
-    identity: string;
-    type: string;
-    profileId: string;
-    roleId: string;
-    resetPassword: boolean;
-    isActive: boolean;
-    isArchived: boolean;
-    role?: RoleDTO;
-    createdAt: string;
-    updatedAt: string;
-}
-/**
- * Represents a user from the admin management perspective.
- * Same person as AuthenticatedUser but with management metadata and capabilities.
- */
-export declare class ManagedUser extends UserEntity {
-    readonly type: string;
-    readonly roleId: string;
-    readonly resetPassword: boolean;
-    readonly isActive: boolean;
-    readonly isArchived: boolean;
-    readonly role?: Role;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    constructor(data: ManagedUserData);
-    /**
-     * Check if user account is active
-     */
-    isAccountActive(): boolean;
-    /**
-     * Check if user account is archived
-     */
-    isAccountArchived(): boolean;
-    /**
-     * Check if user needs to reset password
-     */
-    needsPasswordReset(): boolean;
-    /**
-     * Get comprehensive account status
-     */
-    getAccountStatus(): {
-        status: "active" | "inactive" | "archived" | "password_reset_required";
-        label: string;
-        color: "success" | "warning" | "error" | "default";
-        description: string;
-    };
-    /**
-     * Get role display name
-     */
-    getRoleName(): string;
-    /**
-     * Get formatted creation date
-     */
-    getCreatedDate(): string;
-    /**
-     * Get time since last update
-     */
-    getLastUpdateInfo(): string;
-    static from(data: any): ManagedUser | undefined;
-    static createMany(dataArray: any[]): ManagedUser[];
-    toJSON(): any;
-}

package/dist/modules/user/user.repository.d.ts

@@ -1,179 +0,0 @@
-import { BaseRepository } from "@/lib/api/base-repository.js";
-import { ManagedUser } from "@/modules/user/user.model.js";
-import { Role } from "@/modules/user/role.model.js";
-import { userManagementContract } from "./user.contract.js";
-import { CreateUserRequestDTO, CreateUserResponseDTO, UpdateUserRequestDTO, ResetPasswordRequestDTO, ManagedUserQueryParamsDTO } from "./user.dtos.js";
-/**
- * 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>;
-}