hazo_auth 1.6.0 → 1.6.2

package/dist/lib/services/profile_picture_service.js

@@ -7,7 +7,52 @@ import { create_app_logger } from "../app_logger";
 import path from "path";
 import fs from "fs";
 import { map_ui_source_to_db } from "./profile_picture_source_mapper";
+// section: cache
+// Cache the resolved library path to avoid repeated filesystem checks
+let cached_library_path = null;
+let cached_library_source = null;
 // section: helpers
+/**
+ * Resolves the library path, checking project's public folder first, then node_modules
+ * @returns Object with path and source, or null if not found
+ */
+function resolve_library_path() {
+    // Return cached value if available
+    if (cached_library_path && cached_library_source) {
+        if (fs.existsSync(cached_library_path)) {
+            return { path: cached_library_path, source: cached_library_source };
+        }
+        // Cache is stale, clear it
+        cached_library_path = null;
+        cached_library_source = null;
+    }
+    const config = get_profile_picture_config();
+    const library_subpath = config.library_photo_path.replace(/^\//, "");
+    // Try 1: Project's public folder
+    const project_library_path = path.resolve(process.cwd(), "public", library_subpath);
+    if (fs.existsSync(project_library_path)) {
+        // Check if it has any content (not just empty directory)
+        try {
+            const entries = fs.readdirSync(project_library_path);
+            if (entries.length > 0) {
+                cached_library_path = project_library_path;
+                cached_library_source = "project";
+                return { path: project_library_path, source: "project" };
+            }
+        }
+        catch (_a) {
+            // Continue to fallback
+        }
+    }
+    // Try 2: node_modules/hazo_auth/public folder
+    const node_modules_library_path = path.resolve(process.cwd(), "node_modules", "hazo_auth", "public", library_subpath);
+    if (fs.existsSync(node_modules_library_path)) {
+        cached_library_path = node_modules_library_path;
+        cached_library_source = "node_modules";
+        return { path: node_modules_library_path, source: "node_modules" };
+    }
+    return null;
+}
 /**
  * Generates Gravatar URL from email address
  * @param email - User's email address
@@ -27,13 +72,12 @@ export function get_gravatar_url(email, size) {
  * @returns Array of category names
  */
 export function get_library_categories() {
-    const config = get_profile_picture_config();
-    const library_path = path.resolve(process.cwd(), "public", config.library_photo_path.replace(/^\//, ""));
-    if (!fs.existsSync(library_path)) {
+    const resolved = resolve_library_path();
+    if (!resolved) {
         return [];
     }
     try {
-        const entries = fs.readdirSync(library_path, { withFileTypes: true });
+        const entries = fs.readdirSync(resolved.path, { withFileTypes: true });
         return entries
             .filter((entry) => entry.isDirectory())
             .map((entry) => entry.name)
@@ -45,37 +89,84 @@ export function get_library_categories() {
         logger.warn("profile_picture_service_read_categories_failed", {
             filename: "profile_picture_service.ts",
             line_number: 0,
-            library_path,
+            library_path: resolved.path,
+            source: resolved.source,
             error: error_message,
         });
         return [];
     }
 }
 /**
- * Gets photos in a specific library category
+ * Gets photos in a specific library category with pagination support
  * @param category - Category name
- * @returns Array of photo URLs (relative to public directory)
+ * @param page - Page number (1-indexed, default 1)
+ * @param page_size - Number of photos per page (default 20, max 100)
+ * @returns Object with photos array and pagination info
  */
-export function get_library_photos(category) {
+export function get_library_photos_paginated(category, page = 1, page_size = 20) {
+    const resolved = resolve_library_path();
     const config = get_profile_picture_config();
-    const category_path = path.resolve(process.cwd(), "public", config.library_photo_path.replace(/^\//, ""), category);
+    // Ensure page_size is within bounds
+    const effective_page_size = Math.min(Math.max(1, page_size), 100);
+    const effective_page = Math.max(1, page);
+    if (!resolved) {
+        return {
+            photos: [],
+            total: 0,
+            page: effective_page,
+            page_size: effective_page_size,
+            has_more: false,
+            source: "project",
+        };
+    }
+    const category_path = path.join(resolved.path, category);
     if (!fs.existsSync(category_path)) {
-        return [];
+        return {
+            photos: [],
+            total: 0,
+            page: effective_page,
+            page_size: effective_page_size,
+            has_more: false,
+            source: resolved.source,
+        };
     }
     try {
         const fileTypes = get_file_types_config();
-        const allowedExtensions = fileTypes.allowed_image_extensions.map(ext => `.${ext.toLowerCase()}`);
+        const allowedExtensions = fileTypes.allowed_image_extensions.map(ext => ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`);
         const entries = fs.readdirSync(category_path, { withFileTypes: true });
-        const photos = entries
+        const all_photos = entries
             .filter((entry) => {
             if (!entry.isFile())
                 return false;
             const ext = path.extname(entry.name).toLowerCase();
             return allowedExtensions.includes(ext);
         })
-            .map((entry) => `${config.library_photo_path}/${category}/${entry.name}`)
+            .map((entry) => entry.name)
             .sort();
-        return photos;
+        const total = all_photos.length;
+        const start_index = (effective_page - 1) * effective_page_size;
+        const end_index = start_index + effective_page_size;
+        const page_photos = all_photos.slice(start_index, end_index);
+        // Generate URLs based on source
+        // For node_modules source, we need to serve via API route
+        const photo_urls = page_photos.map((filename) => {
+            if (resolved.source === "node_modules") {
+                // Serve via API route that reads from node_modules
+                return `/api/hazo_auth/library_photo/${category}/${filename}`;
+            }
+            else {
+                // Serve directly from public folder
+                return `${config.library_photo_path}/${category}/${filename}`;
+            }
+        });
+        return {
+            photos: photo_urls,
+            total,
+            page: effective_page,
+            page_size: effective_page_size,
+            has_more: end_index < total,
+            source: resolved.source,
+        };
     }
     catch (error) {
         const logger = create_app_logger();
@@ -85,10 +176,61 @@ export function get_library_photos(category) {
             line_number: 0,
             category,
             category_path,
+            source: resolved.source,
             error: error_message,
         });
-        return [];
+        return {
+            photos: [],
+            total: 0,
+            page: effective_page,
+            page_size: effective_page_size,
+            has_more: false,
+            source: resolved.source,
+        };
+    }
+}
+/**
+ * Gets photos in a specific library category (legacy non-paginated version)
+ * @param category - Category name
+ * @returns Array of photo URLs (relative to public directory or API route)
+ */
+export function get_library_photos(category) {
+    // Use paginated version with large page size for backwards compatibility
+    const result = get_library_photos_paginated(category, 1, 1000);
+    return result.photos;
+}
+/**
+ * Gets the physical file path for a library photo (used for serving from node_modules)
+ * @param category - Category name
+ * @param filename - Photo filename
+ * @returns Full file path or null if not found
+ */
+export function get_library_photo_path(category, filename) {
+    const resolved = resolve_library_path();
+    if (!resolved) {
+        return null;
+    }
+    const photo_path = path.join(resolved.path, category, filename);
+    if (fs.existsSync(photo_path)) {
+        return photo_path;
     }
+    return null;
+}
+/**
+ * Gets the source of library photos (for diagnostic purposes)
+ * @returns Source type or null if no library found
+ */
+export function get_library_source() {
+    var _a;
+    const resolved = resolve_library_path();
+    return (_a = resolved === null || resolved === void 0 ? void 0 : resolved.source) !== null && _a !== void 0 ? _a : null;
+}
+/**
+ * Clears the library path cache (useful for testing or after copying files)
+ */
+export function clear_library_cache() {
+    cached_library_path = null;
+    cached_library_source = null;
 }
 /**
  * Gets default profile picture based on configuration priority

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