hazo_auth 4.5.0 → 4.5.1

package/dist/app/api/hazo_auth/user_management/users/route.d.ts

@@ -14,6 +14,7 @@ export declare function GET(request: NextRequest): Promise<NextResponse<{
         label: string;
         badge_color: string;
     }[];
+    multi_tenancy_enabled: boolean;
     users: {
         id: unknown;
         name: {} | null;
@@ -25,10 +26,12 @@ export declare function GET(request: NextRequest): Promise<NextResponse<{
         profile_picture_url: {} | null;
         profile_source: {} | null;
         user_type: string | null;
+        org_id: string | null | undefined;
+        root_org_id: string | null | undefined;
     }[];
 }>>;
 /**
- * PATCH - Update user (deactivate: set is_active to false)
+ * PATCH - Update user (deactivate: set is_active to false, assign org, etc.)
  */
 export declare function PATCH(request: NextRequest): Promise<NextResponse<{
     error: string;

package/dist/app/api/hazo_auth/user_management/users/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/hazo_auth/user_management/users/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAexD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAGvC;;;GAGG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;IAwE7C;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,WAAW;;;;IA2G/C;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;IA2E9C"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/hazo_auth/user_management/users/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAsBxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAGvC;;;GAGG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;IA+E7C;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,WAAW;;;;IA2L/C;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;IA2E9C"}

package/dist/app/api/hazo_auth/user_management/users/route.js

@@ -9,6 +9,10 @@ import { request_password_reset } from "../../../../../lib/services/password_res
 import { get_auth_cache } from "../../../../../lib/auth/auth_cache";
 import { get_auth_utility_config } from "../../../../../lib/auth_utility_config.server";
 import { is_user_types_enabled, get_all_user_types, get_user_types_config, } from "../../../../../lib/user_types_config.server";
+import { is_multi_tenancy_enabled } from "../../../../../lib/multi_tenancy_config.server";
+import { get_org_by_id, can_add_user_to_org, } from "../../../../../lib/services/org_service";
+import { get_org_cache } from "../../../../../lib/auth/org_cache";
+import { get_multi_tenancy_config } from "../../../../../lib/multi_tenancy_config.server";
 // section: route_config
 export const dynamic = 'force-dynamic';
 // section: api_handler
@@ -42,10 +46,13 @@ export async function GET(request) {
                 badge_color: t.badge_color,
             }))
             : [];
+        // Check if multi-tenancy is enabled
+        const multi_tenancy_enabled = is_multi_tenancy_enabled();
         return NextResponse.json({
             success: true,
             user_types_enabled,
             available_user_types,
+            multi_tenancy_enabled,
             users: users.map((user) => ({
                 id: user.id,
                 name: user.name || null,
@@ -57,6 +64,9 @@ export async function GET(request) {
                 profile_picture_url: user.profile_picture_url || null,
                 profile_source: user.profile_source || null,
                 user_type: user.user_type || null,
+                // Include org info when multi-tenancy is enabled
+                org_id: multi_tenancy_enabled ? user.org_id || null : undefined,
+                root_org_id: multi_tenancy_enabled ? user.root_org_id || null : undefined,
             })),
         }, { status: 200 });
     }
@@ -73,13 +83,13 @@ export async function GET(request) {
     }
 }
 /**
- * PATCH - Update user (deactivate: set is_active to false)
+ * PATCH - Update user (deactivate: set is_active to false, assign org, etc.)
  */
 export async function PATCH(request) {
     const logger = create_app_logger();
     try {
         const body = await request.json();
-        const { user_id, is_active, user_type } = body;
+        const { user_id, is_active, user_type, org_id } = body;
         // user_id is always required
         if (!user_id) {
             return NextResponse.json({ error: "user_id is required" }, { status: 400 });
@@ -88,6 +98,7 @@ export async function PATCH(request) {
         const update_data = {
             changed_at: new Date().toISOString(),
         };
+        const hazoConnect = get_hazo_connect_instance();
         // Handle is_active if provided
         if (typeof is_active === "boolean") {
             update_data.is_active = is_active;
@@ -108,20 +119,53 @@ export async function PATCH(request) {
                 }
             }
         }
+        // Handle org_id if provided (only when multi-tenancy is enabled)
+        if (org_id !== undefined) {
+            if (!is_multi_tenancy_enabled()) {
+                return NextResponse.json({ error: "Multi-tenancy is not enabled" }, { status: 400 });
+            }
+            // Allow null to clear the org assignment
+            if (org_id === null || org_id === "") {
+                update_data.org_id = null;
+                update_data.root_org_id = null;
+            }
+            else {
+                // Validate org exists
+                const org_result = await get_org_by_id(hazoConnect, org_id);
+                if (!org_result.success || !org_result.org) {
+                    return NextResponse.json({ error: "Organization not found" }, { status: 400 });
+                }
+                const org = org_result.org;
+                // Check if org is active
+                if (org.active === false) {
+                    return NextResponse.json({ error: "Cannot assign user to inactive organization" }, { status: 400 });
+                }
+                // Check user limit
+                const limit_check = await can_add_user_to_org(hazoConnect, org_id);
+                if (limit_check.success && !limit_check.can_add) {
+                    return NextResponse.json({ error: limit_check.reason || "Organization user limit reached" }, { status: 400 });
+                }
+                // Set org_id and calculate root_org_id
+                update_data.org_id = org_id;
+                update_data.root_org_id = org.root_org_id || org_id;
+            }
+        }
         // Ensure there's something to update besides changed_at
         if (Object.keys(update_data).length === 1) {
             return NextResponse.json({ error: "No valid fields to update" }, { status: 400 });
         }
-        const hazoConnect = get_hazo_connect_instance();
         const users_service = createCrudService(hazoConnect, "hazo_users");
         // Update user
         await users_service.updateById(user_id, update_data);
-        // Invalidate user cache after deactivation
-        if (is_active === false) {
+        // Invalidate caches
+        let cache_invalidated = false;
+        // Invalidate user auth cache if user deactivated or org changed
+        if (is_active === false || org_id !== undefined) {
             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);
+                const auth_config = get_auth_utility_config();
+                const auth_cache = get_auth_cache(auth_config.cache_max_users, auth_config.cache_ttl_minutes, auth_config.cache_max_age_minutes);
+                auth_cache.invalidate_user(user_id);
+                cache_invalidated = true;
             }
             catch (cache_error) {
                 // Log but don't fail user update if cache invalidation fails
@@ -134,11 +178,34 @@ export async function PATCH(request) {
                 });
             }
         }
+        // If org changed, also invalidate org cache for old and new orgs
+        if (org_id !== undefined && is_multi_tenancy_enabled()) {
+            try {
+                const mt_config = get_multi_tenancy_config();
+                const org_cache = get_org_cache(mt_config.org_cache_max_entries, mt_config.org_cache_ttl_minutes);
+                // Invalidate for the new org if set
+                if (org_id && typeof org_id === "string") {
+                    org_cache.invalidate(org_id);
+                }
+            }
+            catch (cache_error) {
+                // Log but don't fail user update if cache invalidation fails
+                const cache_error_message = cache_error instanceof Error ? cache_error.message : "Unknown error";
+                logger.warn("user_management_org_cache_invalidation_failed", {
+                    filename: get_filename(),
+                    line_number: get_line_number(),
+                    user_id,
+                    org_id,
+                    error: cache_error_message,
+                });
+            }
+        }
         logger.info("user_management_user_updated", {
             filename: get_filename(),
             line_number: get_line_number(),
             user_id,
             updated_fields: Object.keys(update_data).filter((k) => k !== "changed_at"),
+            cache_invalidated,
         });
         return NextResponse.json({ success: true }, { status: 200 });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_auth",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",