hazo_auth 1.2.0 → 1.4.0

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

@@ -0,0 +1,23 @@
+/**
+ * UI representation of profile picture source
+ * Used in components and API interfaces
+ */
+export type ProfilePictureSourceUI = "upload" | "library" | "gravatar" | "custom";
+/**
+ * Database enum values for profile_source
+ * Must match the CHECK constraint in the database
+ */
+export type ProfilePictureSourceDB = "gravatar" | "custom" | "predefined";
+/**
+ * Maps UI profile picture source to database enum value
+ * @param uiSource - UI representation of source ("upload", "library", "gravatar", "custom")
+ * @returns Database enum value ("gravatar", "custom", "predefined")
+ */
+export declare function map_ui_source_to_db(uiSource: ProfilePictureSourceUI): ProfilePictureSourceDB;
+/**
+ * Maps database enum value to UI representation
+ * @param dbSource - Database enum value ("gravatar", "custom", "predefined")
+ * @returns UI representation ("upload", "library", "gravatar", "custom")
+ */
+export declare function map_db_source_to_ui(dbSource: ProfilePictureSourceDB | string | null | undefined): ProfilePictureSourceUI;
+//# sourceMappingURL=profile_picture_source_mapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"profile_picture_source_mapper.d.ts","sourceRoot":"","sources":["../../../src/lib/services/profile_picture_source_mapper.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;AAElF;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,CAAC;AAG1E;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,sBAAsB,CAc5F;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,sBAAsB,CAmBxH"}

package/dist/lib/services/profile_picture_source_mapper.js

@@ -0,0 +1,45 @@
+// section: helpers
+/**
+ * Maps UI profile picture source to database enum value
+ * @param uiSource - UI representation of source ("upload", "library", "gravatar", "custom")
+ * @returns Database enum value ("gravatar", "custom", "predefined")
+ */
+export function map_ui_source_to_db(uiSource) {
+    switch (uiSource) {
+        case "upload":
+            return "custom"; // User uploaded their own photo
+        case "library":
+            return "predefined"; // User selected from predefined library
+        case "gravatar":
+            return "gravatar"; // User's Gravatar
+        case "custom":
+            return "custom"; // Already in database format
+        default:
+            // Fallback to custom for unknown values
+            return "custom";
+    }
+}
+/**
+ * Maps database enum value to UI representation
+ * @param dbSource - Database enum value ("gravatar", "custom", "predefined")
+ * @returns UI representation ("upload", "library", "gravatar", "custom")
+ */
+export function map_db_source_to_ui(dbSource) {
+    if (!dbSource) {
+        return "custom"; // Default fallback
+    }
+    switch (dbSource) {
+        case "gravatar":
+            return "gravatar";
+        case "custom":
+            return "upload"; // Map custom to upload in UI (user uploaded their own)
+        case "predefined":
+            return "library"; // Map predefined to library in UI (user selected from library)
+        default:
+            // For unknown values, try to return as-is if it matches UI format
+            if (dbSource === "upload" || dbSource === "library") {
+                return dbSource;
+            }
+            return "custom"; // Fallback
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { HazoConnectAdapter } from "hazo_connect";
+export type RegistrationData = {
+    email: string;
+    password: string;
+    name?: string;
+    url_on_logon?: string;
+};
+export type RegistrationResult = {
+    success: boolean;
+    user_id?: string;
+    error?: string;
+};
+/**
+ * Registers a new user in the database using hazo_connect
+ * @param adapter - The hazo_connect adapter instance
+ * @param data - Registration data (email, password, optional name)
+ * @returns Registration result with success status and user_id or error
+ */
+export declare function register_user(adapter: HazoConnectAdapter, data: RegistrationData): Promise<RegistrationResult>;
+//# sourceMappingURL=registration_service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registration_service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/registration_service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAcvD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,kBAAkB,CAAC,CA+I7B"}

package/dist/lib/services/registration_service.js

@@ -0,0 +1,147 @@
+import { createCrudService } from "hazo_connect/server";
+import argon2 from "argon2";
+import { randomUUID } from "crypto";
+import { create_token } from "hazo_auth/lib/services/token_service";
+import { get_default_profile_picture } from "hazo_auth/lib/services/profile_picture_service";
+import { get_profile_picture_config } from "hazo_auth/lib/profile_picture_config.server";
+import { map_ui_source_to_db } from "hazo_auth/lib/services/profile_picture_source_mapper";
+import { create_app_logger } from "hazo_auth/lib/app_logger";
+import { send_template_email } from "hazo_auth/lib/services/email_service";
+import { sanitize_error_for_user } from "hazo_auth/lib/utils/error_sanitizer";
+import { get_line_number } from "hazo_auth/lib/utils/api_route_helpers";
+// section: helpers
+/**
+ * Registers a new user in the database using hazo_connect
+ * @param adapter - The hazo_connect adapter instance
+ * @param data - Registration data (email, password, optional name)
+ * @returns Registration result with success status and user_id or error
+ */
+export async function register_user(adapter, data) {
+    try {
+        const { email, password, name, url_on_logon } = data;
+        // Create CRUD service for hazo_users table
+        const users_service = createCrudService(adapter, "hazo_users");
+        // Check if user already exists
+        const existing_users = await users_service.findBy({
+            email_address: email,
+        });
+        if (Array.isArray(existing_users) && existing_users.length > 0) {
+            return {
+                success: false,
+                error: "Email address already registered",
+            };
+        }
+        // Hash password using argon2
+        const password_hash = await argon2.hash(password);
+        // Generate user ID
+        const user_id = randomUUID();
+        const now = new Date().toISOString();
+        // Insert user into database using CRUD service
+        const insert_data = {
+            id: user_id,
+            email_address: email,
+            password_hash: password_hash,
+            email_verified: false,
+            is_active: true,
+            login_attempts: 0,
+            created_at: now,
+            changed_at: now,
+        };
+        // Include name if provided
+        if (name) {
+            insert_data.name = name;
+        }
+        // Validate and include url_on_logon if provided
+        if (url_on_logon) {
+            // Ensure it's a relative path starting with / but not //
+            if (url_on_logon.startsWith("/") && !url_on_logon.startsWith("//")) {
+                insert_data.url_on_logon = url_on_logon;
+            }
+        }
+        // Set default profile picture if enabled
+        const profile_picture_config = get_profile_picture_config();
+        if (profile_picture_config.user_photo_default) {
+            const default_photo = get_default_profile_picture(email, name);
+            if (default_photo) {
+                insert_data.profile_picture_url = default_photo.profile_picture_url;
+                // Map UI source value to database enum value
+                insert_data.profile_source = map_ui_source_to_db(default_photo.profile_source);
+            }
+        }
+        const inserted_users = await users_service.insert(insert_data);
+        // Verify insertion was successful
+        if (!Array.isArray(inserted_users) || inserted_users.length === 0) {
+            return {
+                success: false,
+                error: "Failed to create user account",
+            };
+        }
+        // Create email verification token for the new user
+        const token_result = await create_token({
+            adapter,
+            user_id,
+            token_type: "email_verification",
+        });
+        if (!token_result.success) {
+            // Log error but don't fail registration - token can be resent later
+            const logger = create_app_logger();
+            const error_message = token_result.error || "Unknown error";
+            logger.error("registration_service_token_creation_failed", {
+                filename: "registration_service.ts",
+                line_number: 0,
+                user_id,
+                error: error_message,
+                note: "This may be due to missing token_type column in hazo_refresh_tokens table. Please ensure migration 001_add_token_type_to_refresh_tokens.sql has been applied.",
+            });
+        }
+        else {
+            const logger = create_app_logger();
+            logger.info("registration_service_token_created", {
+                filename: "registration_service.ts",
+                line_number: 0,
+                user_id,
+            });
+        }
+        // Send verification email if token was created successfully
+        if (token_result.success && token_result.raw_token) {
+            const email_result = await send_template_email("email_verification", email, {
+                token: token_result.raw_token,
+                user_email: email,
+                user_name: name,
+            });
+            if (!email_result.success) {
+                const logger = create_app_logger();
+                logger.error("registration_service_email_send_failed", {
+                    filename: "registration_service.ts",
+                    line_number: 0,
+                    user_id,
+                    email,
+                    error: email_result.error,
+                    note: "User registration succeeded but verification email failed to send",
+                });
+            }
+        }
+        return {
+            success: true,
+            user_id,
+        };
+    }
+    catch (error) {
+        const logger = create_app_logger();
+        const user_friendly_error = sanitize_error_for_user(error, {
+            logToConsole: true,
+            logToLogger: true,
+            logger,
+            context: {
+                filename: "registration_service.ts",
+                line_number: get_line_number(),
+                email: data.email,
+                operation: "register_user",
+            },
+        });
+        return {
+            success: false,
+            error: user_friendly_error,
+        };
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { HazoConnectAdapter } from "hazo_connect";
+export type TokenType = "refresh" | "password_reset" | "email_verification";
+export type CreateTokenParams = {
+    adapter: HazoConnectAdapter;
+    user_id: string;
+    token_type: TokenType;
+};
+export type CreateTokenResult = {
+    success: boolean;
+    raw_token?: string;
+    error?: string;
+};
+/**
+ * Creates a token for a user and stores it in hazo_refresh_tokens table
+ * Invalidates any existing tokens of the same type for the user before creating a new one
+ * @param params - Token creation parameters (adapter, user_id, token_type)
+ * @returns Token creation result with raw_token (for sending to user) or error
+ */
+export declare function create_token(params: CreateTokenParams): Promise<CreateTokenResult>;
+//# sourceMappingURL=token_service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"token_service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/token_service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAQvD,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAE5E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,kBAAkB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AA+BF;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,iBAAiB,CAAC,CAiL5B"}

package/dist/lib/services/token_service.js

@@ -0,0 +1,201 @@
+import { createCrudService } from "hazo_connect/server";
+import { randomBytes, randomUUID } from "crypto";
+import argon2 from "argon2";
+import { read_config_section } from "hazo_auth/lib/config/config_loader.server";
+import { create_app_logger } from "hazo_auth/lib/app_logger";
+// section: helpers
+/**
+ * Gets token expiry hours from hazo_auth_config.ini for a specific token type
+ * Falls back to defaults if config is not found
+ * @param token_type - The type of token (refresh, password_reset, email_verification)
+ * @returns Number of hours until token expires
+ */
+function get_token_expiry_hours(token_type) {
+    const default_expiries = {
+        refresh: 720, // 30 days
+        password_reset: 0.167, // 10 minutes
+        email_verification: 48, // 48 hours
+    };
+    const logger = create_app_logger();
+    const token_config_section = read_config_section("hazo_auth__tokens");
+    // Get expiry from config or environment variable or default
+    const config_key = `${token_type}_expiry_hours`;
+    const env_key = `HAZO_AUTH_${token_type.toUpperCase()}_TOKEN_EXPIRY_HOURS`;
+    const expiry_hours = (token_config_section === null || token_config_section === void 0 ? void 0 : token_config_section[config_key]) ||
+        process.env[env_key] ||
+        default_expiries[token_type];
+    return parseFloat(String(expiry_hours)) || default_expiries[token_type];
+}
+/**
+ * Creates a token for a user and stores it in hazo_refresh_tokens table
+ * Invalidates any existing tokens of the same type for the user before creating a new one
+ * @param params - Token creation parameters (adapter, user_id, token_type)
+ * @returns Token creation result with raw_token (for sending to user) or error
+ */
+export async function create_token(params) {
+    try {
+        const { adapter, user_id, token_type } = params;
+        // Create CRUD service for hazo_refresh_tokens table
+        const tokens_service = createCrudService(adapter, "hazo_refresh_tokens");
+        // Invalidate any existing tokens of this type for this user
+        // If token_type column doesn't exist, this will fail - catch and continue
+        let existing_tokens = [];
+        try {
+            existing_tokens = (await tokens_service.findBy({
+                user_id: user_id,
+                token_type: token_type,
+            }));
+        }
+        catch (error) {
+            // If token_type column doesn't exist, try without it
+            // This is a fallback for databases that haven't had the migration applied
+            const logger = create_app_logger();
+            const error_message = error instanceof Error ? error.message : "Unknown error";
+            logger.warn("token_service_token_type_column_missing", {
+                filename: "token_service.ts",
+                line_number: 0,
+                user_id,
+                token_type,
+                error: error_message,
+                note: "token_type column may not exist, trying without filter",
+            });
+            // Try to find tokens by user_id only (less precise but works without migration)
+            try {
+                existing_tokens = (await tokens_service.findBy({
+                    user_id: user_id,
+                }));
+            }
+            catch (fallbackError) {
+                // If that also fails, log and continue (will just create new token)
+                const fallback_error_message = fallbackError instanceof Error ? fallbackError.message : "Unknown error";
+                logger.warn("token_service_query_existing_tokens_failed", {
+                    filename: "token_service.ts",
+                    line_number: 0,
+                    user_id,
+                    error: fallback_error_message,
+                    note: "Could not query existing tokens, will create new token anyway",
+                });
+            }
+        }
+        if (Array.isArray(existing_tokens) && existing_tokens.length > 0) {
+            // Delete existing tokens (of this type if token_type exists, or all for user if not)
+            for (const token of existing_tokens) {
+                try {
+                    await tokens_service.deleteById(token.id);
+                }
+                catch (deleteError) {
+                    const logger = create_app_logger();
+                    const error_message = deleteError instanceof Error ? deleteError.message : "Unknown error";
+                    logger.warn("token_service_delete_existing_token_failed", {
+                        filename: "token_service.ts",
+                        line_number: 0,
+                        user_id,
+                        token_id: token.id,
+                        error: error_message,
+                    });
+                }
+            }
+        }
+        // Generate a secure random token
+        const raw_token = randomBytes(32).toString("hex");
+        // Hash the token before storing
+        const token_hash = await argon2.hash(raw_token);
+        // Get expiry hours from config
+        const expiry_hours = get_token_expiry_hours(token_type);
+        // Calculate expiration time (convert hours to milliseconds)
+        const expires_at = new Date();
+        expires_at.setTime(expires_at.getTime() + expiry_hours * 60 * 60 * 1000);
+        const now = new Date().toISOString();
+        // Insert the token into the database
+        // Try with token_type first, fallback to without if column doesn't exist
+        let inserted_tokens;
+        try {
+            inserted_tokens = (await tokens_service.insert({
+                id: randomUUID(),
+                user_id: user_id,
+                token_hash: token_hash,
+                token_type: token_type,
+                expires_at: expires_at.toISOString(),
+                created_at: now,
+            }));
+        }
+        catch (error) {
+            // If token_type column doesn't exist, try without it
+            const logger = create_app_logger();
+            const error_message = error instanceof Error ? error.message : "Unknown error";
+            logger.warn("token_service_insert_with_token_type_failed", {
+                filename: "token_service.ts",
+                line_number: 0,
+                user_id,
+                token_type,
+                error: error_message,
+                note: "token_type column may not exist, inserting without it",
+            });
+            // Fallback: insert without token_type (will use default if column exists with default)
+            inserted_tokens = (await tokens_service.insert({
+                id: randomUUID(),
+                user_id: user_id,
+                token_hash: token_hash,
+                expires_at: expires_at.toISOString(),
+                created_at: now,
+            }));
+        }
+        // Verify insertion was successful
+        if (!Array.isArray(inserted_tokens) || inserted_tokens.length === 0) {
+            const logger = create_app_logger();
+            const error_msg = `Failed to create ${token_type} token - no rows inserted`;
+            logger.error("token_service_insertion_failed", {
+                filename: "token_service.ts",
+                line_number: 0,
+                user_id,
+                token_type,
+                error: error_msg,
+            });
+            return {
+                success: false,
+                error: error_msg,
+            };
+        }
+        const logger = create_app_logger();
+        logger.info("token_service_token_created", {
+            filename: "token_service.ts",
+            line_number: 0,
+            user_id,
+            token_type,
+        });
+        // Log raw token and test URLs in debug mode (logger handles dev mode)
+        logger.debug("token_service_raw_token", {
+            filename: "token_service.ts",
+            line_number: 0,
+            user_id,
+            token_type,
+            raw_token,
+            test_url: token_type === "email_verification"
+                ? `/hazo_auth/verify_email?token=${raw_token}`
+                : token_type === "password_reset"
+                    ? `/hazo_auth/reset_password?token=${raw_token}`
+                    : undefined,
+        });
+        return {
+            success: true,
+            raw_token,
+        };
+    }
+    catch (error) {
+        const logger = create_app_logger();
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("token_service_create_token_error", {
+            filename: "token_service.ts",
+            line_number: 0,
+            user_id: params.user_id,
+            token_type: params.token_type,
+            error: error_message,
+            error_stack,
+        });
+        return {
+            success: false,
+            error: error_message,
+        };
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { HazoConnectAdapter } from "hazo_connect";
+/**
+ * Basic user profile information returned by get_profiles
+ * Contains resolved profile picture URL, email, name, and account age
+ */
+export type UserProfileInfo = {
+    user_id: string;
+    profile_picture_url: string | null;
+    email: string;
+    name: string | null;
+    days_since_created: number;
+};
+/**
+ * Result type for get_profiles function
+ * Includes found profiles and list of IDs that were not found
+ */
+export type GetProfilesResult = {
+    success: boolean;
+    profiles: UserProfileInfo[];
+    not_found_ids: string[];
+    error?: string;
+};
+/**
+ * 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
+ * @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>;
+//# sourceMappingURL=user_profiles_service.d.ts.map

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

@@ -0,0 +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"}

package/dist/lib/services/user_profiles_service.js

@@ -0,0 +1,99 @@
+import { createCrudService } from "hazo_connect/server";
+import { differenceInDays } from "date-fns";
+import { create_app_logger } from "hazo_auth/lib/app_logger";
+import { sanitize_error_for_user } from "hazo_auth/lib/utils/error_sanitizer";
+// section: helpers
+/**
+ * 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
+ * @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();
+    try {
+        // Handle empty input
+        if (!user_ids || user_ids.length === 0) {
+            return {
+                success: true,
+                profiles: [],
+                not_found_ids: [],
+            };
+        }
+        // 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,
+            };
+        }
+        // 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,
+            message: "Successfully retrieved user profiles",
+            requested_count: unique_user_ids.length,
+            found_count: profiles.length,
+            not_found_count: not_found_ids.length,
+        });
+        return {
+            success: true,
+            profiles,
+            not_found_ids,
+        };
+    }
+    catch (error) {
+        const user_friendly_error = sanitize_error_for_user(error, {
+            logToConsole: true,
+            logToLogger: true,
+            logger,
+            context: {
+                filename: "user_profiles_service.ts",
+                line_number: 122,
+                operation: "hazo_get_user_profiles",
+                user_ids_count: (user_ids === null || user_ids === void 0 ? void 0 : user_ids.length) || 0,
+            },
+        });
+        return {
+            success: false,
+            profiles: [],
+            not_found_ids: [],
+            error: user_friendly_error,
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { HazoConnectAdapter } from "hazo_connect";
+import { type ProfilePictureSourceUI } from "hazo_auth/lib/services/profile_picture_source_mapper";
+export type UserUpdateData = {
+    name?: string;
+    email?: string;
+    profile_picture_url?: string;
+    profile_source?: ProfilePictureSourceUI;
+};
+export type UserUpdateResult = {
+    success: boolean;
+    email_changed?: boolean;
+    error?: string;
+};
+/**
+ * Updates user profile information (name, email)
+ * If email is changed, sets email_verified to false
+ * @param adapter - The hazo_connect adapter instance
+ * @param user_id - The user ID to update
+ * @param data - User update data (name, email)
+ * @returns User update result with success status, email_changed flag, or error
+ */
+export declare function update_user_profile(adapter: HazoConnectAdapter, user_id: string, data: UserUpdateData): Promise<UserUpdateResult>;
+//# sourceMappingURL=user_update_service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user_update_service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/user_update_service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EAAuB,KAAK,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAMxH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,sBAAsB,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAuG3B"}