hazo_auth 4.4.0 → 4.5.0

package/cli-src/lib/services/scope_labels_service.ts

@@ -11,7 +11,7 @@ import { SCOPE_LEVELS } from "./scope_service.js";
 // section: types
 export type ScopeLabel = {
   id: string;
-  org: string;
+  org_id: string;
   scope_type: ScopeLevel;
   label: string;
   created_at: string;
@@ -43,11 +43,11 @@ export const DEFAULT_SCOPE_LABELS: Record<ScopeLevel, string> = {
  */
 export async function get_scope_labels(
   adapter: HazoConnectAdapter,
-  org: string,
+  org_id: string,
 ): Promise<ScopeLabelResult> {
   try {
     const label_service = createCrudService(adapter, "hazo_scope_labels");
-    const labels = await label_service.findBy({ org });
+    const labels = await label_service.findBy({ org_id });
 
     return {
       success: true,
@@ -63,7 +63,7 @@ export async function get_scope_labels(
         filename: "scope_labels_service.ts",
         line_number: 0,
         operation: "get_scope_labels",
-        org,
+        org_id,
       },
     });
 
@@ -79,11 +79,11 @@ export async function get_scope_labels(
  */
 export async function get_scope_labels_with_defaults(
   adapter: HazoConnectAdapter,
-  org: string,
+  org_id: string,
   custom_defaults?: Record<ScopeLevel, string>,
 ): Promise<ScopeLabelResult> {
   try {
-    const result = await get_scope_labels(adapter, org);
+    const result = await get_scope_labels(adapter, org_id);
     if (!result.success) {
       return result;
     }
@@ -107,7 +107,7 @@ export async function get_scope_labels_with_defaults(
         // Create a synthetic label entry (not persisted)
         all_labels.push({
           id: "", // Empty ID indicates this is a default, not from DB
-          org,
+          org_id,
           scope_type: level,
           label: defaults[level],
           created_at: "",
@@ -130,7 +130,7 @@ export async function get_scope_labels_with_defaults(
         filename: "scope_labels_service.ts",
         line_number: 0,
         operation: "get_scope_labels_with_defaults",
-        org,
+        org_id,
       },
     });
 
@@ -147,13 +147,13 @@ export async function get_scope_labels_with_defaults(
  */
 export async function get_label_for_level(
   adapter: HazoConnectAdapter,
-  org: string,
+  org_id: string,
   scope_type: ScopeLevel,
   custom_default?: string,
 ): Promise<string> {
   try {
     const label_service = createCrudService(adapter, "hazo_scope_labels");
-    const labels = await label_service.findBy({ org, scope_type });
+    const labels = await label_service.findBy({ org_id, scope_type });
 
     if (Array.isArray(labels) && labels.length > 0) {
       return (labels[0] as ScopeLabel).label;
@@ -172,7 +172,7 @@ export async function get_label_for_level(
  */
 export async function upsert_scope_label(
   adapter: HazoConnectAdapter,
-  org: string,
+  org_id: string,
   scope_type: ScopeLevel,
   label: string,
 ): Promise<ScopeLabelResult> {
@@ -180,8 +180,8 @@ export async function upsert_scope_label(
     const label_service = createCrudService(adapter, "hazo_scope_labels");
     const now = new Date().toISOString();
 
-    // Check if label already exists for this org + scope_type
-    const existing = await label_service.findBy({ org, scope_type });
+    // Check if label already exists for this org_id + scope_type
+    const existing = await label_service.findBy({ org_id, scope_type });
 
     if (Array.isArray(existing) && existing.length > 0) {
       // Update existing
@@ -206,7 +206,7 @@ export async function upsert_scope_label(
       // Create new
       const inserted = await label_service.insert({
         id: randomUUID(),
-        org,
+        org_id,
         scope_type,
         label,
         created_at: now,
@@ -235,7 +235,7 @@ export async function upsert_scope_label(
         filename: "scope_labels_service.ts",
         line_number: 0,
         operation: "upsert_scope_label",
-        org,
+        org_id,
         scope_type,
         label,
       },
@@ -254,14 +254,14 @@ export async function upsert_scope_label(
  */
 export async function batch_upsert_scope_labels(
   adapter: HazoConnectAdapter,
-  org: string,
+  org_id: string,
   labels: Array<{ scope_type: ScopeLevel; label: string }>,
 ): Promise<ScopeLabelResult> {
   try {
     const results: ScopeLabel[] = [];
 
     for (const { scope_type, label } of labels) {
-      const result = await upsert_scope_label(adapter, org, scope_type, label);
+      const result = await upsert_scope_label(adapter, org_id, scope_type, label);
       if (!result.success) {
         return {
           success: false,
@@ -287,7 +287,7 @@ export async function batch_upsert_scope_labels(
         filename: "scope_labels_service.ts",
         line_number: 0,
         operation: "batch_upsert_scope_labels",
-        org,
+        org_id,
       },
     });
 
@@ -303,14 +303,14 @@ export async function batch_upsert_scope_labels(
  */
 export async function delete_scope_label(
   adapter: HazoConnectAdapter,
-  org: string,
+  org_id: string,
   scope_type: ScopeLevel,
 ): Promise<ScopeLabelResult> {
   try {
     const label_service = createCrudService(adapter, "hazo_scope_labels");
 
     // Find the label
-    const existing = await label_service.findBy({ org, scope_type });
+    const existing = await label_service.findBy({ org_id, scope_type });
 
     if (!Array.isArray(existing) || existing.length === 0) {
       return {
@@ -335,7 +335,7 @@ export async function delete_scope_label(
         filename: "scope_labels_service.ts",
         line_number: 0,
         operation: "delete_scope_label",
-        org,
+        org_id,
         scope_type,
       },
     });

package/cli-src/lib/services/scope_service.ts

@@ -18,7 +18,8 @@ export type ScopeLevel =
 export type ScopeRecord = {
   id: string;
   seq: string;
-  org: string;
+  org_id: string;
+  root_org_id: string;
   name: string;
   parent_scope_id?: string | null;
   created_at: string;
@@ -33,7 +34,8 @@ export type ScopeServiceResult = {
 };
 
 export type CreateScopeData = {
-  org: string;
+  org_id: string;
+  root_org_id: string;
   name: string;
   parent_scope_id?: string;
 };
@@ -99,14 +101,14 @@ export function get_child_level(level: ScopeLevel): ScopeLevel | undefined {
 export async function get_scopes_by_level(
   adapter: HazoConnectAdapter,
   level: ScopeLevel,
-  org?: string,
+  org_id?: string,
 ): Promise<ScopeServiceResult> {
   try {
     const scope_service = createCrudService(adapter, level);
 
     let scopes: unknown[];
-    if (org) {
-      scopes = await scope_service.findBy({ org });
+    if (org_id) {
+      scopes = await scope_service.findBy({ org_id });
     } else {
       scopes = await scope_service.findBy({});
     }
@@ -133,7 +135,7 @@ export async function get_scopes_by_level(
         line_number: 0,
         operation: "get_scopes_by_level",
         level,
-        org,
+        org_id,
       },
     });
 
@@ -272,7 +274,8 @@ export async function create_scope(
     }
 
     const insert_data: Record<string, unknown> = {
-      org: data.org,
+      org_id: data.org_id,
+      root_org_id: data.root_org_id,
       name: data.name,
       created_at: now,
       changed_at: now,
@@ -635,18 +638,19 @@ export type ScopeTreeNode = ScopeRecord & {
 export type OrgScopeTreeNode = {
   id: string;
   name: string;
-  org: string;
+  org_id: string;
+  root_org_id: string;
   isOrgNode: true;
   children: ScopeTreeNode[];
 };
 
 export async function get_scope_tree(
   adapter: HazoConnectAdapter,
-  org: string,
+  org_id: string,
 ): Promise<{ success: boolean; tree?: ScopeTreeNode[]; error?: string }> {
   try {
     // Get all L1 scopes for this org
-    const l1_result = await get_scopes_by_level(adapter, "hazo_scopes_l1", org);
+    const l1_result = await get_scopes_by_level(adapter, "hazo_scopes_l1", org_id);
     if (!l1_result.success || !l1_result.scopes) {
       return l1_result;
     }
@@ -696,7 +700,7 @@ export async function get_scope_tree(
         filename: "scope_service.ts",
         line_number: 0,
         operation: "get_scope_tree",
-        org,
+        org_id,
       },
     });
 

package/cli-src/lib/services/session_token_service.ts

@@ -176,3 +176,7 @@ export async function validate_session_token(
 
 
 
+
+
+
+

package/cli-src/lib/ui_shell_config.server.ts

@@ -1,6 +1,7 @@
 // file_description: load ui shell layout settings from hazo_auth_config.ini
 // section: imports
 import { get_config_value } from "./config/config_loader.server.js";
+import { get_navbar_config, type NavbarConfig } from "./navbar_config.server.js";
 
 // section: types
 export type UiShellLayoutMode = "test_sidebar" | "standalone";
@@ -13,6 +14,10 @@ export type UiShellConfig = {
   standalone_content_class: string;
   standalone_show_heading: boolean;
   standalone_show_description: boolean;
+  /** Navbar configuration for standalone mode */
+  navbar: NavbarConfig;
+  /** Enable vertical centering in standalone mode */
+  vertical_center: boolean;
 };
 
 // section: helpers
@@ -58,6 +63,14 @@ export function get_ui_shell_config(): UiShellConfig {
     "true"
   ).toLowerCase() === "true";
 
+  const vertical_center = get_config_value(
+    section,
+    "vertical_center",
+    "true"
+  ).toLowerCase() === "true";
+
+  const navbar = get_navbar_config();
+
   return {
     layout_mode,
     standalone_heading,
@@ -66,6 +79,8 @@ export function get_ui_shell_config(): UiShellConfig {
     standalone_content_class,
     standalone_show_heading,
     standalone_show_description,
+    navbar,
+    vertical_center,
   };
 }
 

package/cli-src/lib/user_types_config.server.ts

@@ -0,0 +1,178 @@
+// file_description: server-only helper to read user types configuration from hazo_auth_config.ini
+// section: imports
+import {
+  get_config_value,
+  get_config_boolean,
+  read_config_section,
+} from "./config/config_loader.server.js";
+import { DEFAULT_USER_TYPES } from "./config/default_config.js";
+
+// section: types
+
+/**
+ * Badge color preset names supported by the UserTypeBadge component
+ */
+export type BadgeColorPreset =
+  | "blue"
+  | "green"
+  | "red"
+  | "yellow"
+  | "purple"
+  | "gray"
+  | "orange"
+  | "pink";
+
+/**
+ * Individual user type definition parsed from config
+ */
+export type UserTypeDefinition = {
+  /** Unique key stored in database (e.g., "admin", "standard") */
+  key: string;
+  /** Display label (e.g., "Administrator", "Standard User") */
+  label: string;
+  /** Badge color - preset name or hex value */
+  badge_color: string;
+  /** Whether this is a preset color or custom hex */
+  is_preset_color: boolean;
+};
+
+/**
+ * User types configuration options
+ */
+export type UserTypesConfig = {
+  /** Whether user types feature is enabled (default: false) */
+  enable_user_types: boolean;
+  /** Default user type for new users (empty = no default) */
+  default_user_type: string;
+  /** Map of user type definitions by key */
+  user_types: Map<string, UserTypeDefinition>;
+};
+
+// section: constants
+
+const SECTION_NAME = "hazo_auth__user_types";
+
+const PRESET_COLORS = new Set<BadgeColorPreset>([
+  "blue",
+  "green",
+  "red",
+  "yellow",
+  "purple",
+  "gray",
+  "orange",
+  "pink",
+]);
+
+// section: helpers
+
+/**
+ * Parses a user type definition string
+ * Format: key:label:color (e.g., "admin:Administrator:red" or "custom:Custom Type:#4CAF50")
+ * @param value - The config value string
+ * @returns UserTypeDefinition or null if invalid
+ */
+function parse_user_type_definition(value: string): UserTypeDefinition | null {
+  const parts = value.split(":").map((s) => s.trim());
+  if (parts.length < 2) return null;
+
+  const key = parts[0];
+  const label = parts[1];
+  const badge_color = parts[2] || "gray";
+
+  if (!key || !label) return null;
+
+  return {
+    key,
+    label,
+    badge_color,
+    is_preset_color: PRESET_COLORS.has(badge_color as BadgeColorPreset),
+  };
+}
+
+/**
+ * Reads user types configuration from hazo_auth_config.ini file
+ * Falls back to defaults if config file is not found or section is missing
+ * @returns User types configuration options
+ */
+export function get_user_types_config(): UserTypesConfig {
+  const enable_user_types = get_config_boolean(
+    SECTION_NAME,
+    "enable_user_types",
+    DEFAULT_USER_TYPES.enable_user_types
+  );
+
+  const default_user_type = get_config_value(
+    SECTION_NAME,
+    "default_user_type",
+    DEFAULT_USER_TYPES.default_user_type
+  );
+
+  // Parse user type definitions from config
+  const user_types = new Map<string, UserTypeDefinition>();
+  const section = read_config_section(SECTION_NAME);
+
+  if (section) {
+    // Look for user_type_1, user_type_2, etc. (up to 50 types supported)
+    for (let i = 1; i <= 50; i++) {
+      const key = `user_type_${i}`;
+      const value = section[key];
+      if (!value) continue;
+
+      const type_def = parse_user_type_definition(value);
+      if (type_def) {
+        user_types.set(type_def.key, type_def);
+      }
+    }
+  }
+
+  return {
+    enable_user_types,
+    default_user_type,
+    user_types,
+  };
+}
+
+/**
+ * Checks if user types feature is enabled in the configuration
+ * Convenience function for quick checks
+ */
+export function is_user_types_enabled(): boolean {
+  return get_config_boolean(
+    SECTION_NAME,
+    "enable_user_types",
+    DEFAULT_USER_TYPES.enable_user_types
+  );
+}
+
+/**
+ * Gets the default user type from config
+ * Returns empty string if not configured
+ */
+export function get_default_user_type(): string {
+  return get_config_value(
+    SECTION_NAME,
+    "default_user_type",
+    DEFAULT_USER_TYPES.default_user_type
+  );
+}
+
+/**
+ * Gets user type definition by key
+ * @param type_key - The user type key
+ * @returns UserTypeDefinition or undefined if not found
+ */
+export function get_user_type_by_key(
+  type_key: string
+): UserTypeDefinition | undefined {
+  const config = get_user_types_config();
+  return config.user_types.get(type_key);
+}
+
+/**
+ * Gets all user type definitions as array (for UI dropdowns)
+ * @returns Array of UserTypeDefinition objects
+ */
+export function get_all_user_types(): UserTypeDefinition[] {
+  const config = get_user_types_config();
+  return Array.from(config.user_types.values());
+}

package/cli-src/server/types/app_types.ts

@@ -1,19 +1,17 @@
 // file_description: define shared application level types for the hazo_auth server
 // section: request_context_types
 import type { Request } from "express";
+import type { Logger, LogData } from "hazo_logs";
 
 // section: logger_interface_definition
+// Re-export hazo_logs types for backward compatibility
 export type logger_method = (
   message: string,
-  data?: Record<string, unknown>
+  data?: LogData
 ) => void;
 
-export type logger_service = {
-  debug: logger_method;
-  info: logger_method;
-  warn: logger_method;
-  error: logger_method;
-};
+// Use hazo_logs Logger type as logger_service for backward compatibility
+export type logger_service = Logger;
 
 // section: configuration_types
 export type emailer_client = {

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

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/me/route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;IA2F7C"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/me/route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAaxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;IA4G7C"}

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

@@ -8,6 +8,7 @@ import { createCrudService } from "hazo_connect/server";
 import { map_db_source_to_ui } from "../../../../lib/services/profile_picture_source_mapper";
 import { create_app_logger } from "../../../../lib/app_logger";
 import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+import { is_user_types_enabled, get_user_type_by_key, } from "../../../../lib/user_types_config.server";
 // section: api_handler
 /**
  * GET /api/hazo_auth/me
@@ -71,6 +72,19 @@ export async function GET(request) {
         // Check if user has a password set
         const password_hash = user_db.password_hash;
         const has_password = password_hash !== null && password_hash !== undefined && password_hash !== "";
+        // Get user type info if feature is enabled
+        const user_type = user_db.user_type || null;
+        let user_type_info = null;
+        if (is_user_types_enabled() && user_type) {
+            const type_def = get_user_type_by_key(user_type);
+            if (type_def) {
+                user_type_info = {
+                    key: type_def.key,
+                    label: type_def.label,
+                    badge_color: type_def.badge_color,
+                };
+            }
+        }
         // Return unified format with all fields
         const profile_pic = auth_result.user.profile_picture_url;
         return NextResponse.json({
@@ -91,6 +105,9 @@ export async function GET(request) {
             auth_providers,
             has_password,
             google_connected: auth_providers.includes("google"),
+            // User type fields (when feature is enabled)
+            user_type,
+            user_type_info,
             // Permissions and user object (always included)
             user: auth_result.user,
             permissions: auth_result.permissions,

package/dist/app/api/hazo_auth/org_management/orgs/route.d.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare const dynamic = "force-dynamic";
+/**
+ * GET - Fetch organizations
+ * Query params:
+ * - action: 'list' | 'tree' (default: 'list')
+ * - include_inactive: boolean (default: false)
+ * - root_org_id: string (optional, filter by root org - required unless global admin)
+ */
+export declare function GET(request: NextRequest): Promise<NextResponse<unknown>>;
+/**
+ * POST - Create a new organization
+ * Body: { name: string, user_limit?: number, parent_org_id?: string }
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse<unknown>>;
+/**
+ * PATCH - Update an existing organization
+ * Body: { org_id: string, name?: string, user_limit?: number }
+ */
+export declare function PATCH(request: NextRequest): Promise<NextResponse<unknown>>;
+/**
+ * DELETE - Soft delete an organization (sets active = false)
+ * Query params: org_id
+ */
+export declare function DELETE(request: NextRequest): Promise<NextResponse<unknown>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/org_management/orgs/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/hazo_auth/org_management/orgs/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiBxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAqDvC;;;;;;GAMG;AACH,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW,kCAmF7C;AAED;;;GAGG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,kCA6F9C;AAED;;;GAGG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,WAAW,kCA2G/C;AAED;;;GAGG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,WAAW,kCA4EhD"}