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

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>;
-}