hazo_auth 1.0.5 → 1.2.0

package/src/lib/services/user_profiles_service.ts

@@ -0,0 +1,143 @@
+// file_description: service for batch retrieval of basic user profile information for chat applications and similar use cases
+// section: imports
+import type { HazoConnectAdapter } from "hazo_connect";
+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";
+
+// section: types
+/**
+ * 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;
+};
+
+// 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: HazoConnectAdapter,
+  user_ids: string[],
+): Promise<GetProfilesResult> {
+  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 as string));
+
+    // 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: UserProfileInfo[] = users.map((user) => {
+      const created_at = user.created_at as string;
+      const created_date = new Date(created_at);
+      const days_since_created = differenceInDays(now, created_date);
+
+      return {
+        user_id: user.id as string,
+        profile_picture_url: (user.profile_picture_url as string) || null,
+        email: user.email_address as string,
+        name: (user.name as string) || 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?.length || 0,
+      },
+    });
+
+    return {
+      success: false,
+      profiles: [],
+      not_found_ids: [],
+      error: user_friendly_error,
+    };
+  }
+}
+

package/src/lib/services/user_update_service.ts

@@ -3,6 +3,9 @@
 import type { HazoConnectAdapter } from "hazo_connect";
 import { createCrudService } from "hazo_connect/server";
 import { map_ui_source_to_db, type ProfilePictureSourceUI } from "./profile_picture_source_mapper";
+import { create_app_logger } from "../app_logger";
+import { sanitize_error_for_user } from "../utils/error_sanitizer";
+import { get_filename, get_line_number } from "../utils/api_route_helpers";
 
 // section: types
 export type UserUpdateData = {
@@ -116,12 +119,22 @@ export async function update_user_profile(
       email_changed,
     };
   } catch (error) {
-    const error_message =
-      error instanceof Error ? error.message : "Unknown error";
+    const logger = create_app_logger();
+    const user_friendly_error = sanitize_error_for_user(error, {
+      logToConsole: true,
+      logToLogger: true,
+      logger,
+      context: {
+        filename: "user_update_service.ts",
+        line_number: get_line_number(),
+        user_id,
+        operation: "update_user_profile",
+      },
+    });
 
     return {
       success: false,
-      error: error_message,
+      error: user_friendly_error,
     };
   }
 }

package/src/lib/ui_shell_config.server.ts

@@ -0,0 +1,73 @@
+// file_description: load ui shell layout settings from hazo_auth_config.ini
+// section: imports
+import { get_config_value } from "./config/config_loader.server";
+
+// section: types
+export type UiShellLayoutMode = "test_sidebar" | "standalone";
+
+export type UiShellConfig = {
+  layout_mode: UiShellLayoutMode;
+  standalone_heading: string;
+  standalone_description: string;
+  standalone_wrapper_class: string;
+  standalone_content_class: string;
+  standalone_show_heading: boolean;
+  standalone_show_description: boolean;
+};
+
+// section: helpers
+/**
+ * Reads ui shell configuration controlling whether pages use the sidebar test shell
+ * or a clean standalone wrapper that inherits consumer project styling.
+ */
+export function get_ui_shell_config(): UiShellConfig {
+  const section = "hazo_auth__ui_shell";
+
+  const layoutModeValue = get_config_value(section, "layout_mode", "test_sidebar").toLowerCase();
+  const layout_mode: UiShellLayoutMode =
+    layoutModeValue === "standalone" ? "standalone" : "test_sidebar";
+
+  const standalone_heading = get_config_value(
+    section,
+    "standalone_heading",
+    "Welcome to hazo auth"
+  );
+  const standalone_description = get_config_value(
+    section,
+    "standalone_description",
+    "Reuse the packaged authentication flows while inheriting your existing app shell styles."
+  );
+  const standalone_wrapper_class = get_config_value(
+    section,
+    "standalone_wrapper_class",
+    "cls_standalone_shell flex min-h-screen w-full items-center justify-center bg-background px-4 py-10"
+  );
+  const standalone_content_class = get_config_value(
+    section,
+    "standalone_content_class",
+    "cls_standalone_shell_content w-full max-w-5xl shadow-xl rounded-2xl border bg-card"
+  );
+  const standalone_show_heading = get_config_value(
+    section,
+    "standalone_show_heading",
+    "true"
+  ).toLowerCase() === "true";
+  const standalone_show_description = get_config_value(
+    section,
+    "standalone_show_description",
+    "true"
+  ).toLowerCase() === "true";
+
+  return {
+    layout_mode,
+    standalone_heading,
+    standalone_description,
+    standalone_wrapper_class,
+    standalone_content_class,
+    standalone_show_heading,
+    standalone_show_description,
+  };
+}
+
+
+

package/src/lib/utils/error_sanitizer.ts

@@ -0,0 +1,75 @@
+// file_description: utility functions for sanitizing error messages for user display
+// section: imports
+import { create_app_logger } from "../app_logger";
+
+// section: constants
+const USER_FRIENDLY_ERROR_MESSAGE = "We are facing some issues in our system, please try again later.";
+
+// section: types
+export type ErrorSanitizationOptions = {
+  logToConsole?: boolean;
+  logToLogger?: boolean;
+  logger?: ReturnType<typeof create_app_logger>;
+  context?: Record<string, unknown>;
+};
+
+// section: helpers
+/**
+ * Sanitizes error messages for user display
+ * Replaces technical error messages with user-friendly ones
+ * @param error - The error object or message
+ * @param options - Options for logging and context
+ * @returns User-friendly error message
+ */
+export function sanitize_error_for_user(
+  error: unknown,
+  options: ErrorSanitizationOptions = {}
+): string {
+  const { logToConsole = true, logToLogger = true, logger, context = {} } = options;
+
+  // Extract detailed error message
+  const detailed_error_message =
+    error instanceof Error ? error.message : String(error);
+  const error_stack = error instanceof Error ? error.stack : undefined;
+
+  // Log detailed error to console
+  if (logToConsole) {
+    console.error("Detailed error:", {
+      message: detailed_error_message,
+      stack: error_stack,
+      ...context,
+    });
+  }
+
+  // Log detailed error to logger if provided
+  if (logToLogger && logger) {
+    logger.error("error_occurred", {
+      filename: context.filename as string || "unknown",
+      line_number: context.line_number as number || 0,
+      error_message: detailed_error_message,
+      error_stack,
+      ...context,
+    });
+  }
+
+  // Check if error is a PostgREST or database-related error
+  const is_database_error =
+    detailed_error_message.includes("PostgREST") ||
+    detailed_error_message.includes("403 Forbidden") ||
+    detailed_error_message.includes("404 Not Found") ||
+    detailed_error_message.includes("500 Internal Server Error") ||
+    detailed_error_message.includes("database") ||
+    detailed_error_message.includes("connection") ||
+    detailed_error_message.includes("timeout");
+
+  // Return user-friendly message for database/API errors
+  if (is_database_error) {
+    return USER_FRIENDLY_ERROR_MESSAGE;
+  }
+
+  // For other errors, return the original message (could be user-friendly already)
+  // But still log the detailed error
+  return detailed_error_message;
+}
+
+