@temboplus/afloat 0.1.81 → 0.2.0-beta.2

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

@@ -0,0 +1,73 @@
+/** 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

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

@@ -0,0 +1,75 @@
+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;
+    /**
+     * Filter by date range with support for Date objects, strings, and null
+     * Internally converts to createdAt:gte and createdAt:lte filters
+     */
+    whereDateBetween(startDate?: string | Date | null, endDate?: string | Date | 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

@@ -0,0 +1,36 @@
+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/{esm/src/features/auth/contract.d.ts → dist/modules/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,12 +47,15 @@ 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">;
                 resetPassword: z.ZodBoolean;
             }, "strip", z.ZodTypeAny, {
+                token: string;
                 resetPassword: boolean;
+                access: string[];
                 profile: {
                     id: string;
                     displayName: string;
@@ -59,11 +64,12 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
+                    autoApprove?: boolean | null | undefined;
                 };
-                token: string;
-                access: string[];
             }, {
+                token: string;
                 resetPassword: boolean;
+                access: string[];
                 profile: {
                     id: string;
                     displayName: string;
@@ -72,9 +78,8 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
+                    autoApprove?: boolean | null | undefined;
                 };
-                token: string;
-                access: string[];
             }>;
             400: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
         };
@@ -82,13 +87,6 @@ export declare const authContract: {
     access: {
         method: "GET";
         path: "/access";
-        headers: z.ZodObject<{
-            token: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-        }, {
-            token: string;
-        }>;
         responses: {
             200: z.ZodArray<z.ZodString, "many">;
         };
@@ -99,14 +97,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/modules/auth/auth.repository.d.ts

@@ -0,0 +1,83 @@
+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[]>;
+}

package/dist/modules/auth/company-membership.model.d.ts

@@ -0,0 +1,171 @@
+import z from "zod";
+import { Profile } from "../profile/profile.model.js";
+import { Role } from "../team-member/role.model.js";
+/**
+ * Zod schema for CompanyMembership JSON serialization
+ */
+export declare const CompanyMembershipJSONSchema: z.ZodObject<{
+    companyProfile: z.ZodObject<{
+        id: z.ZodString;
+        firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        displayName: z.ZodString;
+        phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        accountNo: z.ZodString;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        autoApprove: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        displayName: string;
+        accountNo: string;
+        version: string;
+        firstName?: string | null | undefined;
+        lastName?: string | null | undefined;
+        phone?: string | null | undefined;
+        email?: string | null | undefined;
+        autoApprove?: boolean | null | undefined;
+    }, {
+        id: string;
+        displayName: string;
+        accountNo: string;
+        firstName?: string | null | undefined;
+        lastName?: string | null | undefined;
+        phone?: string | null | undefined;
+        email?: string | null | undefined;
+        autoApprove?: boolean | null | undefined;
+        version?: string | undefined;
+    }>;
+    role: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        access: z.ZodArray<z.ZodString, "many">;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        createdAt: string;
+        id: string;
+        version: string;
+        updatedAt: string;
+        access: string[];
+        description?: string | undefined;
+    }, {
+        name: string;
+        createdAt: string;
+        id: string;
+        updatedAt: string;
+        access: string[];
+        version?: string | undefined;
+        description?: string | undefined;
+    }>>;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    companyProfile: {
+        id: string;
+        displayName: string;
+        accountNo: string;
+        version: string;
+        firstName?: string | null | undefined;
+        lastName?: string | null | undefined;
+        phone?: string | null | undefined;
+        email?: string | null | undefined;
+        autoApprove?: boolean | null | undefined;
+    };
+    role?: {
+        name: string;
+        createdAt: string;
+        id: string;
+        version: string;
+        updatedAt: string;
+        access: string[];
+        description?: string | undefined;
+    } | undefined;
+}, {
+    companyProfile: {
+        id: string;
+        displayName: string;
+        accountNo: string;
+        firstName?: string | null | undefined;
+        lastName?: string | null | undefined;
+        phone?: string | null | undefined;
+        email?: string | null | undefined;
+        autoApprove?: boolean | null | undefined;
+        version?: string | undefined;
+    };
+    version?: string | undefined;
+    role?: {
+        name: string;
+        createdAt: string;
+        id: string;
+        updatedAt: string;
+        access: string[];
+        version?: string | undefined;
+        description?: string | undefined;
+    } | undefined;
+}>;
+export type CompanyMembershipJSON = z.infer<typeof CompanyMembershipJSONSchema>;
+export type CompanyMembershipData = {
+    companyProfile: Profile;
+    role?: Role;
+};
+/**
+ * Represents a user's membership within a company.
+ *
+ * This class encapsulates the relationship between a user and their company:
+ * - The company profile the user belongs to
+ * - The user's role within that company (optional - depends on permissions)
+ *
+ * Note: Permissions are stored in LogIn.access, not here.
+ * This model focuses purely on the company-user relationship.
+ *
+ * The role may be undefined if the user doesn't have permission to view
+ * role details (Permissions.Role.ViewRole).
+ */
+export declare class CompanyMembership {
+    private readonly _companyProfile;
+    private readonly _role?;
+    private constructor();
+    /**
+     * Creates a CompanyMembership instance from the required data.
+     *
+     * @param data - The membership data
+     * @returns A new CompanyMembership instance, or undefined if invalid
+     *
+     * @example
+     * ```typescript
+     * const membership = CompanyMembership.from({
+     *   companyProfile: profile,
+     *   role: role // optional
+     * });
+     * ```
+     */
+    static from(data: CompanyMembershipData): CompanyMembership | undefined;
+    /**
+     * Gets the company profile.
+     */
+    get companyProfile(): Profile;
+    /**
+     * Gets the user's role (may be undefined if user lacks permission to view it).
+     */
+    get role(): Role | undefined;
+    /**
+    * Serializes the CompanyMembership instance to a JSON-compatible object
+    */
+    toJSON(): CompanyMembershipJSON;
+    /**
+     * Serializes the CompanyMembership instance to a JSON string
+     */
+    toJSONString(): string;
+    /**
+     * Creates a CompanyMembership instance from a JSON-compatible object or string
+     */
+    static fromJSON(json: CompanyMembershipJSON | string): CompanyMembership | undefined;
+    /**
+     * Type guard using Zod schema validation
+     */
+    static isCompanyMembershipJSON(obj: unknown): obj is CompanyMembershipJSON;
+}

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

@@ -0,0 +1,3 @@
+export * from "./auth.repository.js";
+export * from "./user.model.js";
+export * from "./company-membership.model.js";