hazo_auth 1.6.1 → 1.6.4

package/dist/lib/services/user_profiles_cache.d.ts

@@ -0,0 +1,76 @@
+import type { UserProfileInfo } from "./user_profiles_service";
+/**
+ * LRU cache implementation with TTL and size limits for user profiles
+ * Uses Map to maintain insertion order for LRU eviction
+ */
+declare class UserProfilesCache {
+    private cache;
+    private max_size;
+    private ttl_ms;
+    constructor(max_size: number, ttl_minutes: number);
+    /**
+     * Gets a cached profile for a user
+     * Returns undefined if not found or expired
+     * @param user_id - User ID to look up
+     * @returns Profile or undefined
+     */
+    get(user_id: string): UserProfileInfo | undefined;
+    /**
+     * Gets multiple profiles from cache
+     * Returns object with found profiles and missing IDs
+     * @param user_ids - Array of user IDs to look up
+     * @returns Object with cached profiles and IDs not in cache
+     */
+    get_many(user_ids: string[]): {
+        cached: UserProfileInfo[];
+        missing_ids: string[];
+    };
+    /**
+     * Sets a cache entry for a user profile
+     * Evicts least recently used entries if cache is full
+     * @param user_id - User ID
+     * @param profile - User profile data
+     */
+    set(user_id: string, profile: UserProfileInfo): void;
+    /**
+     * Sets multiple cache entries at once
+     * @param profiles - Array of user profiles to cache
+     */
+    set_many(profiles: UserProfileInfo[]): void;
+    /**
+     * Invalidates cache for a specific user
+     * @param user_id - User ID to invalidate
+     */
+    invalidate_user(user_id: string): void;
+    /**
+     * Invalidates cache for multiple users
+     * @param user_ids - Array of user IDs to invalidate
+     */
+    invalidate_users(user_ids: string[]): void;
+    /**
+     * Invalidates all cache entries
+     */
+    invalidate_all(): void;
+    /**
+     * Gets cache statistics
+     * @returns Object with cache size and max size
+     */
+    get_stats(): {
+        size: number;
+        max_size: number;
+        ttl_minutes: number;
+    };
+}
+/**
+ * Gets or creates the global user profiles cache instance
+ * @param max_size - Maximum cache size (default: 5000)
+ * @param ttl_minutes - TTL in minutes (default: 5)
+ * @returns User profiles cache instance
+ */
+export declare function get_user_profiles_cache(max_size?: number, ttl_minutes?: number): UserProfilesCache;
+/**
+ * Resets the global cache instance (useful for testing)
+ */
+export declare function reset_user_profiles_cache(): void;
+export {};
+//# sourceMappingURL=user_profiles_cache.d.ts.map

package/dist/lib/services/user_profiles_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user_profiles_cache.d.ts","sourceRoot":"","sources":["../../../src/lib/services/user_profiles_cache.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAc/D;;;GAGG;AACH,cAAM,iBAAiB;IACrB,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAS;gBAEX,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAMjD;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAuBjD;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG;QAC5B,MAAM,EAAE,eAAe,EAAE,CAAC;QAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;KACvB;IAgBD;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI;IAmBpD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,IAAI;IAM3C;;;OAGG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAItC;;;OAGG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;IAM1C;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;;OAGG;IACH,SAAS,IAAI;QACX,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;KACrB;CAOF;AAMD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,GAAE,MAAa,EACvB,WAAW,GAAE,MAAU,GACtB,iBAAiB,CAKnB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}

package/dist/lib/services/user_profiles_cache.js

@@ -0,0 +1,141 @@
+// section: cache_class
+/**
+ * LRU cache implementation with TTL and size limits for user profiles
+ * Uses Map to maintain insertion order for LRU eviction
+ */
+class UserProfilesCache {
+    constructor(max_size, ttl_minutes) {
+        this.cache = new Map();
+        this.max_size = max_size;
+        this.ttl_ms = ttl_minutes * 60 * 1000;
+    }
+    /**
+     * Gets a cached profile for a user
+     * Returns undefined if not found or expired
+     * @param user_id - User ID to look up
+     * @returns Profile or undefined
+     */
+    get(user_id) {
+        const entry = this.cache.get(user_id);
+        if (!entry) {
+            return undefined;
+        }
+        const now = Date.now();
+        const age = now - entry.timestamp;
+        // Check if entry is expired
+        if (age > this.ttl_ms) {
+            this.cache.delete(user_id);
+            return undefined;
+        }
+        // Move to end (most recently used)
+        this.cache.delete(user_id);
+        this.cache.set(user_id, entry);
+        return entry.profile;
+    }
+    /**
+     * Gets multiple profiles from cache
+     * Returns object with found profiles and missing IDs
+     * @param user_ids - Array of user IDs to look up
+     * @returns Object with cached profiles and IDs not in cache
+     */
+    get_many(user_ids) {
+        const cached = [];
+        const missing_ids = [];
+        for (const user_id of user_ids) {
+            const profile = this.get(user_id);
+            if (profile) {
+                cached.push(profile);
+            }
+            else {
+                missing_ids.push(user_id);
+            }
+        }
+        return { cached, missing_ids };
+    }
+    /**
+     * Sets a cache entry for a user profile
+     * Evicts least recently used entries if cache is full
+     * @param user_id - User ID
+     * @param profile - User profile data
+     */
+    set(user_id, profile) {
+        // Evict LRU entries if cache is full
+        while (this.cache.size >= this.max_size) {
+            const first_key = this.cache.keys().next().value;
+            if (first_key) {
+                this.cache.delete(first_key);
+            }
+            else {
+                break;
+            }
+        }
+        const entry = {
+            profile,
+            timestamp: Date.now(),
+        };
+        this.cache.set(user_id, entry);
+    }
+    /**
+     * Sets multiple cache entries at once
+     * @param profiles - Array of user profiles to cache
+     */
+    set_many(profiles) {
+        for (const profile of profiles) {
+            this.set(profile.user_id, profile);
+        }
+    }
+    /**
+     * Invalidates cache for a specific user
+     * @param user_id - User ID to invalidate
+     */
+    invalidate_user(user_id) {
+        this.cache.delete(user_id);
+    }
+    /**
+     * Invalidates cache for multiple users
+     * @param user_ids - Array of user IDs to invalidate
+     */
+    invalidate_users(user_ids) {
+        for (const user_id of user_ids) {
+            this.cache.delete(user_id);
+        }
+    }
+    /**
+     * Invalidates all cache entries
+     */
+    invalidate_all() {
+        this.cache.clear();
+    }
+    /**
+     * Gets cache statistics
+     * @returns Object with cache size and max size
+     */
+    get_stats() {
+        return {
+            size: this.cache.size,
+            max_size: this.max_size,
+            ttl_minutes: this.ttl_ms / 60000,
+        };
+    }
+}
+// section: singleton
+// Global cache instance (initialized with defaults, will be configured on first use)
+let user_profiles_cache_instance = null;
+/**
+ * Gets or creates the global user profiles cache instance
+ * @param max_size - Maximum cache size (default: 5000)
+ * @param ttl_minutes - TTL in minutes (default: 5)
+ * @returns User profiles cache instance
+ */
+export function get_user_profiles_cache(max_size = 5000, ttl_minutes = 5) {
+    if (!user_profiles_cache_instance) {
+        user_profiles_cache_instance = new UserProfilesCache(max_size, ttl_minutes);
+    }
+    return user_profiles_cache_instance;
+}
+/**
+ * Resets the global cache instance (useful for testing)
+ */
+export function reset_user_profiles_cache() {
+    user_profiles_cache_instance = null;
+}

package/dist/lib/services/user_profiles_service.d.ts

@@ -19,13 +19,30 @@ export type GetProfilesResult = {
     profiles: UserProfileInfo[];
     not_found_ids: string[];
     error?: string;
+    cache_stats?: {
+        hits: number;
+        misses: number;
+        cache_enabled: boolean;
+    };
 };
 /**
  * Retrieves basic profile information for multiple users in a single batch call
  * Useful for chat applications and similar use cases where basic user info is needed
+ * Uses LRU cache with configurable TTL for performance (default: 5 minutes)
  * @param adapter - The hazo_connect adapter instance
  * @param user_ids - Array of user IDs to retrieve profiles for
  * @returns GetProfilesResult with found profiles and list of not found IDs
  */
 export declare function hazo_get_user_profiles(adapter: HazoConnectAdapter, user_ids: string[]): Promise<GetProfilesResult>;
+/**
+ * Invalidates cache for specific user IDs
+ * Call this after user profile updates to ensure fresh data on next fetch
+ * @param user_ids - Array of user IDs to invalidate from cache
+ */
+export declare function invalidate_user_profiles_cache(user_ids: string[]): void;
+/**
+ * Invalidates the entire user profiles cache
+ * Use sparingly - prefer invalidating specific users when possible
+ */
+export declare function invalidate_all_user_profiles_cache(): void;
 //# sourceMappingURL=user_profiles_service.d.ts.map

package/dist/lib/services/user_profiles_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user_profiles_service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/user_profiles_service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAOvD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,iBAAiB,CAAC,CAkG5B"}
+{"version":3,"file":"user_profiles_service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/user_profiles_service.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AASvD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,aAAa,EAAE,OAAO,CAAC;KACxB,CAAC;CACH,CAAC;AAuDF;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,iBAAiB,CAAC,CA4H5B;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAWvE;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,IAAI,IAAI,CAWzD"}

package/dist/lib/services/user_profiles_service.js

@@ -2,16 +2,60 @@ import { createCrudService } from "hazo_connect/server";
 import { differenceInDays } from "date-fns";
 import { create_app_logger } from "../app_logger";
 import { sanitize_error_for_user } from "../utils/error_sanitizer";
+import { get_user_profiles_cache } from "./user_profiles_cache";
+import { get_user_profiles_cache_config } from "../user_profiles_config.server";
 // section: helpers
+/**
+ * Fetches profiles from database for given user IDs
+ * @param adapter - The hazo_connect adapter instance
+ * @param user_ids - Array of user IDs to fetch
+ * @returns Object with profiles and not found IDs
+ */
+async function fetch_profiles_from_db(adapter, user_ids) {
+    const users_service = createCrudService(adapter, "hazo_users");
+    // Query users by IDs using the 'in' filter
+    // PostgREST supports 'in' filter syntax: id=in.(id1,id2,id3)
+    const users = await users_service.findBy({
+        id: `in.(${user_ids.join(",")})`,
+    });
+    // Handle case where no users are found
+    if (!Array.isArray(users)) {
+        return {
+            profiles: [],
+            not_found_ids: user_ids,
+        };
+    }
+    // Build set of found user IDs for quick lookup
+    const found_user_ids = new Set(users.map((user) => user.id));
+    // Determine which user IDs were not found
+    const not_found_ids = user_ids.filter((id) => !found_user_ids.has(id));
+    // Transform database records to UserProfileInfo
+    const now = new Date();
+    const profiles = users.map((user) => {
+        const created_at = user.created_at;
+        const created_date = new Date(created_at);
+        const days_since_created = differenceInDays(now, created_date);
+        return {
+            user_id: user.id,
+            profile_picture_url: user.profile_picture_url || null,
+            email: user.email_address,
+            name: user.name || null,
+            days_since_created,
+        };
+    });
+    return { profiles, not_found_ids };
+}
 /**
  * Retrieves basic profile information for multiple users in a single batch call
  * Useful for chat applications and similar use cases where basic user info is needed
+ * Uses LRU cache with configurable TTL for performance (default: 5 minutes)
  * @param adapter - The hazo_connect adapter instance
  * @param user_ids - Array of user IDs to retrieve profiles for
  * @returns GetProfilesResult with found profiles and list of not found IDs
  */
 export async function hazo_get_user_profiles(adapter, user_ids) {
     const logger = create_app_logger();
+    const config = get_user_profiles_cache_config();
     try {
         // Handle empty input
         if (!user_ids || user_ids.length === 0) {
@@ -19,62 +63,85 @@ export async function hazo_get_user_profiles(adapter, user_ids) {
                 success: true,
                 profiles: [],
                 not_found_ids: [],
+                cache_stats: {
+                    hits: 0,
+                    misses: 0,
+                    cache_enabled: config.cache_enabled,
+                },
             };
         }
         // Remove duplicates from input
         const unique_user_ids = [...new Set(user_ids)];
-        // Create CRUD service for hazo_users table
-        const users_service = createCrudService(adapter, "hazo_users");
-        // Query users by IDs using the 'in' filter
-        // PostgREST supports 'in' filter syntax: id=in.(id1,id2,id3)
-        const users = await users_service.findBy({
-            id: `in.(${unique_user_ids.join(",")})`,
-        });
-        // Handle case where no users are found
-        if (!Array.isArray(users)) {
-            logger.warn("hazo_get_user_profiles_unexpected_response", {
-                filename: "user_profiles_service.ts",
-                line_number: 70,
-                message: "Unexpected response format from database query",
-                user_ids: unique_user_ids,
-            });
-            return {
-                success: true,
-                profiles: [],
-                not_found_ids: unique_user_ids,
-            };
+        // Initialize variables for cache tracking
+        let cache_hits = 0;
+        let cache_misses = 0;
+        let all_profiles = [];
+        let all_not_found_ids = [];
+        if (config.cache_enabled) {
+            // Get cache instance with config settings
+            const cache = get_user_profiles_cache(config.cache_max_entries, config.cache_ttl_minutes);
+            // Check cache first
+            const { cached, missing_ids } = cache.get_many(unique_user_ids);
+            cache_hits = cached.length;
+            cache_misses = missing_ids.length;
+            // If all profiles were cached, return immediately
+            if (missing_ids.length === 0) {
+                logger.info("hazo_get_user_profiles_cache_hit_all", {
+                    filename: "user_profiles_service.ts",
+                    line_number: 130,
+                    message: "All profiles served from cache",
+                    requested_count: unique_user_ids.length,
+                    cache_hits,
+                });
+                return {
+                    success: true,
+                    profiles: cached,
+                    not_found_ids: [],
+                    cache_stats: {
+                        hits: cache_hits,
+                        misses: 0,
+                        cache_enabled: true,
+                    },
+                };
+            }
+            // Fetch missing profiles from database
+            const db_result = await fetch_profiles_from_db(adapter, missing_ids);
+            // Cache the newly fetched profiles
+            if (db_result.profiles.length > 0) {
+                cache.set_many(db_result.profiles);
+            }
+            // Combine cached and freshly fetched profiles
+            all_profiles = [...cached, ...db_result.profiles];
+            all_not_found_ids = db_result.not_found_ids;
+        }
+        else {
+            // Cache disabled - fetch all from database
+            cache_misses = unique_user_ids.length;
+            const db_result = await fetch_profiles_from_db(adapter, unique_user_ids);
+            all_profiles = db_result.profiles;
+            all_not_found_ids = db_result.not_found_ids;
         }
-        // Build set of found user IDs for quick lookup
-        const found_user_ids = new Set(users.map((user) => user.id));
-        // Determine which user IDs were not found
-        const not_found_ids = unique_user_ids.filter((id) => !found_user_ids.has(id));
-        // Transform database records to UserProfileInfo
-        const now = new Date();
-        const profiles = users.map((user) => {
-            const created_at = user.created_at;
-            const created_date = new Date(created_at);
-            const days_since_created = differenceInDays(now, created_date);
-            return {
-                user_id: user.id,
-                profile_picture_url: user.profile_picture_url || null,
-                email: user.email_address,
-                name: user.name || null,
-                days_since_created,
-            };
-        });
         // Log successful retrieval
         logger.info("hazo_get_user_profiles_success", {
             filename: "user_profiles_service.ts",
-            line_number: 105,
+            line_number: 170,
             message: "Successfully retrieved user profiles",
             requested_count: unique_user_ids.length,
-            found_count: profiles.length,
-            not_found_count: not_found_ids.length,
+            found_count: all_profiles.length,
+            not_found_count: all_not_found_ids.length,
+            cache_hits,
+            cache_misses,
+            cache_enabled: config.cache_enabled,
         });
         return {
             success: true,
-            profiles,
-            not_found_ids,
+            profiles: all_profiles,
+            not_found_ids: all_not_found_ids,
+            cache_stats: {
+                hits: cache_hits,
+                misses: cache_misses,
+                cache_enabled: config.cache_enabled,
+            },
         };
     }
     catch (error) {
@@ -84,7 +151,7 @@ export async function hazo_get_user_profiles(adapter, user_ids) {
             logger,
             context: {
                 filename: "user_profiles_service.ts",
-                line_number: 122,
+                line_number: 195,
                 operation: "hazo_get_user_profiles",
                 user_ids_count: (user_ids === null || user_ids === void 0 ? void 0 : user_ids.length) || 0,
             },
@@ -97,3 +164,28 @@ export async function hazo_get_user_profiles(adapter, user_ids) {
         };
     }
 }
+/**
+ * Invalidates cache for specific user IDs
+ * Call this after user profile updates to ensure fresh data on next fetch
+ * @param user_ids - Array of user IDs to invalidate from cache
+ */
+export function invalidate_user_profiles_cache(user_ids) {
+    const config = get_user_profiles_cache_config();
+    if (!config.cache_enabled) {
+        return;
+    }
+    const cache = get_user_profiles_cache(config.cache_max_entries, config.cache_ttl_minutes);
+    cache.invalidate_users(user_ids);
+}
+/**
+ * Invalidates the entire user profiles cache
+ * Use sparingly - prefer invalidating specific users when possible
+ */
+export function invalidate_all_user_profiles_cache() {
+    const config = get_user_profiles_cache_config();
+    if (!config.cache_enabled) {
+        return;
+    }
+    const cache = get_user_profiles_cache(config.cache_max_entries, config.cache_ttl_minutes);
+    cache.invalidate_all();
+}

package/dist/lib/user_profiles_config.server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * User profiles cache configuration options
+ */
+export type UserProfilesCacheConfig = {
+    cache_enabled: boolean;
+    cache_max_entries: number;
+    cache_ttl_minutes: number;
+};
+/**
+ * Reads user profiles cache configuration from hazo_auth_config.ini file
+ * Falls back to defaults if hazo_auth_config.ini is not found or section is missing
+ * @returns User profiles cache configuration options
+ */
+export declare function get_user_profiles_cache_config(): UserProfilesCacheConfig;
+//# sourceMappingURL=user_profiles_config.server.d.ts.map

package/dist/lib/user_profiles_config.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user_profiles_config.server.d.ts","sourceRoot":"","sources":["../../src/lib/user_profiles_config.server.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,8BAA8B,IAAI,uBAAuB,CA6BxE"}

package/dist/lib/user_profiles_config.server.js

@@ -0,0 +1,23 @@
+// file_description: server-only helper to read user profiles cache configuration from hazo_auth_config.ini
+// section: imports
+import { get_config_number, } from "./config/config_loader.server";
+// section: helpers
+/**
+ * Reads user profiles cache configuration from hazo_auth_config.ini file
+ * Falls back to defaults if hazo_auth_config.ini is not found or section is missing
+ * @returns User profiles cache configuration options
+ */
+export function get_user_profiles_cache_config() {
+    const section_name = "hazo_auth__user_profiles";
+    // Cache settings
+    // cache_enabled: 0 = disabled, 1 = enabled (default: 1)
+    const cache_enabled_num = get_config_number(section_name, "cache_enabled", 1);
+    const cache_enabled = cache_enabled_num === 1;
+    const cache_max_entries = get_config_number(section_name, "cache_max_entries", 5000);
+    const cache_ttl_minutes = get_config_number(section_name, "cache_ttl_minutes", 5);
+    return {
+        cache_enabled,
+        cache_max_entries,
+        cache_ttl_minutes,
+    };
+}

package/hazo_auth_config.example.ini

@@ -305,17 +305,21 @@ enable_admin_ui = true
 # default_super_user_email = admin@example.com
 
 [hazo_auth__auth_utility]
-# Authentication utility configuration
+# Authentication utility configuration for hazo_get_auth()
+# This function retrieves the current user, their permissions, and role IDs from cookies
+# Results are cached in memory to improve performance on repeated calls
 
 # Cache settings
 # Maximum number of users to cache (LRU eviction, default: 10000)
 # cache_max_users = 10000
 
-# Cache TTL in minutes (default: 15)
-# cache_ttl_minutes = 15
+# Cache TTL in minutes - how long cached auth data is valid (default: 5)
+# After TTL expires, the next call will fetch fresh data from database
+# cache_ttl_minutes = 5
 
-# Force cache refresh if older than this many minutes (default: 30)
-# cache_max_age_minutes = 30
+# Force cache refresh if older than this many minutes (default: 10)
+# This is the hard limit - entries older than this are always refreshed
+# cache_max_age_minutes = 10
 
 # Rate limiting for /api/auth/get_auth endpoint
 # Per-user rate limit (requests per minute, default: 100)
@@ -336,6 +340,22 @@ enable_admin_ui = true
 # Example: admin_user_management:You don't have access to user management,admin_role_management:You don't have access to role management
 # permission_error_messages = 
 
+[hazo_auth__user_profiles]
+# User profiles cache configuration for hazo_get_user_profiles()
+# This function retrieves basic profile info (name, email, profile picture) for multiple users
+# Used by chat applications and similar use cases where batch user info is needed
+# Results are cached in memory to improve performance on repeated calls
+
+# Enable caching (1 = enabled, 0 = disabled, default: 1)
+# cache_enabled = 1
+
+# Maximum number of user profiles to cache (LRU eviction, default: 5000)
+# cache_max_entries = 5000
+
+# Cache TTL in minutes - how long cached profile data is valid (default: 5)
+# After TTL expires, the next call will fetch fresh data from database
+# cache_ttl_minutes = 5
+
 [hazo_auth__profile_pic_menu]
 # Profile picture menu configuration
 # This component can be used in navbar or sidebar to show user profile picture or sign up/sign in buttons

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_auth",
-  "version": "1.6.1",
+  "version": "1.6.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -12,6 +12,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
     "./components/layouts/login": {
       "types": "./dist/components/layouts/login/index.d.ts",
       "import": "./dist/components/layouts/login/index.js"