hazo_auth 1.4.2 → 1.6.1

package/dist/app/api/hazo_auth/change_password/route.d.ts

@@ -0,0 +1,8 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    message: string;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/change_password/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/change_password/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAUxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IAsH9C"}

package/dist/app/api/hazo_auth/change_password/route.js

@@ -0,0 +1,98 @@
+// file_description: API route for changing user password
+// section: imports
+import { NextResponse } from "next/server";
+import { get_hazo_connect_instance } from "../../../../lib/hazo_connect_instance.server";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { change_password } from "../../../../lib/services/password_change_service";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+import { require_auth } from "../../../../lib/auth/auth_utils.server";
+import { get_auth_cache } from "../../../../lib/auth/auth_cache";
+import { get_auth_utility_config } from "../../../../lib/auth_utility_config.server";
+// section: api_handler
+export async function POST(request) {
+    const logger = create_app_logger();
+    try {
+        // Use centralized auth check
+        let user_id;
+        try {
+            const user = await require_auth(request);
+            user_id = user.user_id;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "Authentication required") {
+                logger.warn("password_change_authentication_failed", {
+                    filename: get_filename(),
+                    line_number: get_line_number(),
+                    error: "User not authenticated",
+                });
+                return NextResponse.json({ error: "Authentication required" }, { status: 401 });
+            }
+            throw error;
+        }
+        const body = await request.json();
+        const { current_password, new_password } = body;
+        // Validate input
+        if (!current_password || !new_password) {
+            logger.warn("password_change_validation_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                error: "Missing required fields",
+                has_current_password: !!current_password,
+                has_new_password: !!new_password,
+            });
+            return NextResponse.json({ error: "Current password and new password are required" }, { status: 400 });
+        }
+        // Get singleton hazo_connect instance
+        const hazoConnect = get_hazo_connect_instance();
+        // Change password
+        const result = await change_password(hazoConnect, user_id, {
+            current_password,
+            new_password,
+        });
+        if (!result.success) {
+            logger.warn("password_change_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                error: result.error,
+                user_id,
+            });
+            return NextResponse.json({ error: result.error || "Failed to change password" }, { status: 400 });
+        }
+        // Invalidate user cache after password change
+        try {
+            const config = get_auth_utility_config();
+            const cache = get_auth_cache(config.cache_max_users, config.cache_ttl_minutes, config.cache_max_age_minutes);
+            cache.invalidate_user(user_id);
+        }
+        catch (cache_error) {
+            // Log but don't fail password change if cache invalidation fails
+            const cache_error_message = cache_error instanceof Error ? cache_error.message : "Unknown error";
+            logger.warn("password_change_cache_invalidation_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id,
+                error: cache_error_message,
+            });
+        }
+        logger.info("password_change_successful", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            user_id,
+        });
+        return NextResponse.json({
+            success: true,
+            message: "Password changed successfully",
+        }, { status: 200 });
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("password_change_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error_message,
+            error_stack,
+        });
+        return NextResponse.json({ error: "Failed to change password. Please try again." }, { status: 500 });
+    }
+}

package/dist/app/api/hazo_auth/forgot_password/route.d.ts

@@ -0,0 +1,8 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    message: string;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/forgot_password/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/forgot_password/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAOxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IAgG9C"}

package/dist/app/api/hazo_auth/forgot_password/route.js

@@ -0,0 +1,78 @@
+// file_description: API route for password reset requests using hazo_connect
+// section: imports
+import { NextResponse } from "next/server";
+import { get_hazo_connect_instance } from "../../../../lib/hazo_connect_instance.server";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { request_password_reset } from "../../../../lib/services/password_reset_service";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+// section: api_handler
+export async function POST(request) {
+    const logger = create_app_logger();
+    try {
+        const body = await request.json();
+        const { email } = body;
+        // Validate input
+        if (!email) {
+            logger.warn("password_reset_validation_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                email: email || "missing",
+            });
+            return NextResponse.json({ error: "Email is required" }, { status: 400 });
+        }
+        // Validate email format
+        const email_pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!email_pattern.test(email)) {
+            logger.warn("password_reset_invalid_email", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                email,
+            });
+            return NextResponse.json({ error: "Invalid email address format" }, { status: 400 });
+        }
+        // Get singleton hazo_connect instance (reuses same connection across all routes)
+        const hazoConnect = get_hazo_connect_instance();
+        // Request password reset using the password reset service
+        const result = await request_password_reset(hazoConnect, {
+            email,
+        });
+        if (!result.success) {
+            logger.warn("password_reset_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                email,
+                error: result.error,
+            });
+            // Still return 200 OK to prevent email enumeration attacks
+            return NextResponse.json({
+                success: true,
+                message: "If an account with that email exists, a password reset link has been sent.",
+            }, { status: 200 });
+        }
+        logger.info("password_reset_requested", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            email,
+        });
+        // Always return success to prevent email enumeration attacks
+        return NextResponse.json({
+            success: true,
+            message: "If an account with that email exists, a password reset link has been sent.",
+        }, { status: 200 });
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("password_reset_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error_message,
+            error_stack,
+        });
+        // Still return 200 OK to prevent email enumeration attacks
+        return NextResponse.json({
+            success: true,
+            message: "If an account with that email exists, a password reset link has been sent.",
+        }, { status: 200 });
+    }
+}

package/dist/app/api/hazo_auth/get_auth/route.d.ts

@@ -0,0 +1,10 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare const dynamic = "force-dynamic";
+/**
+ * POST - Get authentication status and permissions
+ * Body: { required_permissions?: string[], strict?: boolean }
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<import("../../../..").HazoAuthResult>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/get_auth/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/get_auth/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAOxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAGvC;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;yDAuE9C"}

package/dist/app/api/hazo_auth/get_auth/route.js

@@ -0,0 +1,63 @@
+// file_description: API route for hazo_get_auth utility (client-side calls)
+// section: imports
+import { NextResponse } from "next/server";
+import { hazo_get_auth } from "../../../../lib/auth/hazo_get_auth.server";
+import { PermissionError } from "../../../../lib/auth/auth_types";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+// section: route_config
+export const dynamic = "force-dynamic";
+// section: api_handler
+/**
+ * POST - Get authentication status and permissions
+ * Body: { required_permissions?: string[], strict?: boolean }
+ */
+export async function POST(request) {
+    const logger = create_app_logger();
+    try {
+        const body = await request.json();
+        const { required_permissions, strict } = body;
+        // Validate required_permissions if provided
+        if (required_permissions !== undefined &&
+            (!Array.isArray(required_permissions) ||
+                !required_permissions.every((p) => typeof p === "string"))) {
+            return NextResponse.json({ error: "required_permissions must be an array of strings" }, { status: 400 });
+        }
+        // Validate strict if provided
+        if (strict !== undefined && typeof strict !== "boolean") {
+            return NextResponse.json({ error: "strict must be a boolean" }, { status: 400 });
+        }
+        // Call hazo_get_auth
+        const result = await hazo_get_auth(request, {
+            required_permissions,
+            strict,
+        });
+        return NextResponse.json(result, { status: 200 });
+    }
+    catch (error) {
+        // Handle PermissionError (strict mode)
+        if (error instanceof PermissionError) {
+            logger.warn("auth_utility_permission_error", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                missing_permissions: error.missing_permissions,
+                required_permissions: error.required_permissions,
+            });
+            return NextResponse.json({
+                error: "Permission denied",
+                missing_permissions: error.missing_permissions,
+                user_friendly_message: error.user_friendly_message,
+            }, { status: 403 });
+        }
+        // Handle other errors
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("auth_utility_api_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error_message,
+            error_stack,
+        });
+        return NextResponse.json({ error: error_message }, { status: 500 });
+    }
+}

package/dist/app/api/hazo_auth/invalidate_cache/route.d.ts

@@ -0,0 +1,14 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare const dynamic = "force-dynamic";
+/**
+ * POST - Manually invalidate auth cache
+ * Body: { user_id?: string, role_ids?: number[], invalidate_all?: boolean }
+ * Requires admin permission (checked via hazo_get_auth)
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    message: string;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/invalidate_cache/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/invalidate_cache/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAQxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAGvC;;;;GAIG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;IAuH9C"}

package/dist/app/api/hazo_auth/invalidate_cache/route.js

@@ -0,0 +1,96 @@
+// file_description: API route for manual cache invalidation (admin endpoint)
+// section: imports
+import { NextResponse } from "next/server";
+import { get_auth_cache } from "../../../../lib/auth/auth_cache";
+import { get_auth_utility_config } from "../../../../lib/auth_utility_config.server";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+import { hazo_get_auth } from "../../../../lib/auth/hazo_get_auth.server";
+// section: route_config
+export const dynamic = "force-dynamic";
+// section: api_handler
+/**
+ * POST - Manually invalidate auth cache
+ * Body: { user_id?: string, role_ids?: number[], invalidate_all?: boolean }
+ * Requires admin permission (checked via hazo_get_auth)
+ */
+export async function POST(request) {
+    const logger = create_app_logger();
+    try {
+        // Check authentication and admin permission
+        const auth_result = await hazo_get_auth(request, {
+            required_permissions: ["admin_user_management"], // Require admin permission
+            strict: true, // Throw error if not authorized
+        });
+        if (!auth_result.authenticated) {
+            return NextResponse.json({ error: "Authentication required" }, { status: 401 });
+        }
+        const body = await request.json();
+        const { user_id, role_ids, invalidate_all } = body;
+        // Validate input
+        if (invalidate_all !== undefined && typeof invalidate_all !== "boolean") {
+            return NextResponse.json({ error: "invalidate_all must be a boolean" }, { status: 400 });
+        }
+        if (user_id !== undefined && typeof user_id !== "string") {
+            return NextResponse.json({ error: "user_id must be a string" }, { status: 400 });
+        }
+        if (role_ids !== undefined &&
+            (!Array.isArray(role_ids) ||
+                !role_ids.every((id) => typeof id === "number"))) {
+            return NextResponse.json({ error: "role_ids must be an array of numbers" }, { status: 400 });
+        }
+        const config = get_auth_utility_config();
+        const cache = get_auth_cache(config.cache_max_users, config.cache_ttl_minutes, config.cache_max_age_minutes);
+        // Perform invalidation
+        if (invalidate_all === true) {
+            cache.invalidate_all();
+            logger.info("auth_cache_invalidated_all", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id: auth_result.user.id,
+            });
+        }
+        else if (user_id) {
+            cache.invalidate_user(user_id);
+            logger.info("auth_cache_invalidated_user", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                invalidated_user_id: user_id,
+                admin_user_id: auth_result.user.id,
+            });
+        }
+        else if (role_ids && role_ids.length > 0) {
+            cache.invalidate_by_roles(role_ids);
+            logger.info("auth_cache_invalidated_roles", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                role_ids,
+                admin_user_id: auth_result.user.id,
+            });
+        }
+        else {
+            return NextResponse.json({
+                error: "Must provide user_id, role_ids, or invalidate_all=true",
+            }, { status: 400 });
+        }
+        return NextResponse.json({
+            success: true,
+            message: "Cache invalidated successfully",
+        }, { status: 200 });
+    }
+    catch (error) {
+        // Handle PermissionError (strict mode)
+        if (error instanceof Error && error.name === "PermissionError") {
+            return NextResponse.json({ error: "Permission denied. Admin access required." }, { status: 403 });
+        }
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("auth_cache_invalidation_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error_message,
+            error_stack,
+        });
+        return NextResponse.json({ error: "Failed to invalidate cache" }, { status: 500 });
+    }
+}

package/dist/app/api/hazo_auth/library_photo/[category]/[filename]/route.d.ts

@@ -0,0 +1,9 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare const dynamic = "force-dynamic";
+export declare function GET(request: NextRequest, { params }: {
+    params: {
+        category: string;
+        filename: string;
+    };
+}): Promise<NextResponse<unknown>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/library_photo/[category]/[filename]/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/api/hazo_auth/library_photo/[category]/[filename]/route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAevC,wBAAsB,GAAG,CACvB,OAAO,EAAE,WAAW,EACpB,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,kCA4E/D"}

package/dist/app/api/hazo_auth/library_photo/[category]/[filename]/route.js

@@ -0,0 +1,82 @@
+// file_description: API route to serve library photos from node_modules fallback
+// This route is used when library photos haven't been copied to the project's public folder
+// section: imports
+import { NextResponse } from "next/server";
+import { get_library_photo_path } from "../../../../../../lib/services/profile_picture_service";
+import { create_app_logger } from "../../../../../../lib/app_logger";
+import { get_filename, get_line_number } from "../../../../../../lib/utils/api_route_helpers";
+import fs from "fs";
+import path from "path";
+// section: route_config
+// Cache library photos for 1 hour (they don't change)
+export const dynamic = 'force-dynamic';
+// section: constants
+const MIME_TYPES = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+};
+const CACHE_MAX_AGE = 3600; // 1 hour in seconds
+// section: api_handler
+export async function GET(request, { params }) {
+    const logger = create_app_logger();
+    const { category, filename } = params;
+    try {
+        // Validate inputs to prevent path traversal
+        if (category.includes("..") ||
+            category.includes("/") ||
+            category.includes("\\") ||
+            filename.includes("..") ||
+            filename.includes("/") ||
+            filename.includes("\\")) {
+            logger.warn("library_photo_invalid_path", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                category,
+                requested_filename: filename,
+            });
+            return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+        }
+        // Get the physical file path
+        const photo_path = get_library_photo_path(category, filename);
+        if (!photo_path) {
+            logger.warn("library_photo_not_found", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                category,
+                requested_filename: filename,
+            });
+            return NextResponse.json({ error: "Photo not found" }, { status: 404 });
+        }
+        // Read the file
+        const file_buffer = fs.readFileSync(photo_path);
+        const ext = path.extname(filename).toLowerCase();
+        const content_type = MIME_TYPES[ext] || "application/octet-stream";
+        // Return the image with caching headers
+        return new NextResponse(file_buffer, {
+            status: 200,
+            headers: {
+                "Content-Type": content_type,
+                "Content-Length": file_buffer.length.toString(),
+                "Cache-Control": `public, max-age=${CACHE_MAX_AGE}, immutable`,
+                "X-Library-Source": "node_modules",
+            },
+        });
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("library_photo_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            category,
+            requested_filename: filename,
+            error_message,
+            error_stack,
+        });
+        return NextResponse.json({ error: "Failed to serve photo" }, { status: 500 });
+    }
+}

package/dist/app/api/hazo_auth/library_photos/route.d.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare const dynamic = "force-dynamic";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    success: boolean;
+    category: string;
+    photos: string[];
+    pagination: {
+        page: number;
+        page_size: number;
+        total: number;
+        has_more: boolean;
+        total_pages: number;
+    };
+    source: "project" | "node_modules";
+}> | NextResponse<{
+    success: boolean;
+    categories: string[];
+    source: "project" | "node_modules" | null;
+}> | NextResponse<{
+    error: string;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/library_photos/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/library_photos/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAUxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAOvC,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;IAmF7C"}

package/dist/app/api/hazo_auth/library_photos/route.js

@@ -0,0 +1,80 @@
+// file_description: API route for listing library photo categories and photos in categories with pagination support
+// section: imports
+import { NextResponse } from "next/server";
+import { get_library_categories, get_library_photos_paginated, get_library_source } from "../../../../lib/services/profile_picture_service";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+// section: route_config
+export const dynamic = 'force-dynamic';
+// section: constants
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+// section: api_handler
+export async function GET(request) {
+    const logger = create_app_logger();
+    try {
+        const { searchParams } = new URL(request.url);
+        const category = searchParams.get("category");
+        const page_param = searchParams.get("page");
+        const page_size_param = searchParams.get("page_size");
+        // Parse pagination parameters
+        const page = page_param ? Math.max(1, parseInt(page_param, 10) || 1) : 1;
+        const page_size = page_size_param
+            ? Math.min(MAX_PAGE_SIZE, Math.max(1, parseInt(page_size_param, 10) || DEFAULT_PAGE_SIZE))
+            : DEFAULT_PAGE_SIZE;
+        if (category) {
+            // Return photos in the specified category with pagination
+            const result = get_library_photos_paginated(category, page, page_size);
+            logger.info("library_photos_category_requested", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                category,
+                page,
+                page_size,
+                total: result.total,
+                returned: result.photos.length,
+                source: result.source,
+            });
+            return NextResponse.json({
+                success: true,
+                category,
+                photos: result.photos,
+                pagination: {
+                    page: result.page,
+                    page_size: result.page_size,
+                    total: result.total,
+                    has_more: result.has_more,
+                    total_pages: Math.ceil(result.total / result.page_size),
+                },
+                source: result.source,
+            }, { status: 200 });
+        }
+        else {
+            // Return list of categories
+            const categories = get_library_categories();
+            const source = get_library_source();
+            logger.info("library_categories_requested", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                categoryCount: categories.length,
+                source,
+            });
+            return NextResponse.json({
+                success: true,
+                categories,
+                source,
+            }, { status: 200 });
+        }
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("library_photos_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error_message,
+            error_stack,
+        });
+        return NextResponse.json({ error: "Failed to fetch library photos" }, { status: 500 });
+    }
+}

package/dist/app/api/hazo_auth/login/route.d.ts

@@ -0,0 +1,12 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    message: string;
+    user_id: string;
+    email: any;
+    name: string | undefined;
+    redirectUrl: string;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/login/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/login/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;;IAwK9C"}