indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/core/client.js

@@ -0,0 +1,301 @@
+'use client';
+// Core API Client
+// Handles HTTP requests with authentication and session management
+import { getGlobalAPIConfig, getBasicAuthHeader, buildAPIURL, setGlobalAPIConfig } from './config.js';
+import { safeJSONParse } from './utils.js';
+// Global session-expired handler — set by SessionExpiryMonitor or any top-level component
+// When a 401 or "session not found" response is received, this callback is invoked to redirect to login
+let _onSessionExpired = null;
+export function setSessionExpiredHandler(handler) {
+    _onSessionExpired = handler;
+}
+let _isSigningOut = false;
+export function handleSessionExpired() {
+    if (_isSigningOut || !_onSessionExpired)
+        return;
+    _isSigningOut = true;
+    try {
+        _onSessionExpired();
+    }
+    finally {
+        // Reset after a delay so multiple rapid 401s don't fire multiple times
+        setTimeout(() => { _isSigningOut = false; }, 5000);
+    }
+}
+/**
+ * APIClient class for making HTTP requests to the backend API
+ */
+class APIClient {
+    /**
+     * Make a generic API request
+     * @param endpoint - API endpoint (relative to base URL)
+     * @param options - Fetch options
+     * @param sessionData - Optional session data for CompanyID and UserID headers
+     * @returns Promise<APIResponse>
+     */
+    static async request(endpoint, options = {}, sessionData, baseURLOverride, externalSignal, timeoutMs) {
+        try {
+            // Check if API configuration is set
+            let config = getGlobalAPIConfig();
+            // If not configured, try to initialize with session company credentials
+            if (!config && sessionData?.user) {
+                const baseURL = process.env.NEXT_PUBLIC_API_BASE_URL;
+                const companyUsername = sessionData.user.companyUsername;
+                const companyPassword = sessionData.user.companyPassword;
+                if (baseURL && companyUsername && companyPassword) {
+                    setGlobalAPIConfig({
+                        baseURL,
+                        username: companyUsername,
+                        password: companyPassword,
+                        timeout: 60000
+                    });
+                    config = getGlobalAPIConfig();
+                }
+                else if (baseURL) {
+                    // No company credentials in session - user needs to re-login
+                    console.error('❌ [APIClient] No company credentials in session');
+                    console.error('❌ [APIClient] User session is outdated - please log out and log back in');
+                    throw new Error('Session outdated: Please log out and log back in to refresh your credentials');
+                }
+            }
+            // Build complete URL (use override if provided)
+            let url;
+            if (baseURLOverride) {
+                const base = baseURLOverride.endsWith('/') ? baseURLOverride : `${baseURLOverride}/`;
+                const clean = endpoint.startsWith('/') ? endpoint.slice(1) : endpoint;
+                url = `${base}${clean}`;
+            }
+            else {
+                url = buildAPIURL(endpoint);
+            }
+            if (!url) {
+                throw new Error('API configuration not set. Please configure the API connection.');
+            }
+            // Get Basic Auth header from config
+            const authHeader = getBasicAuthHeader();
+            if (!authHeader) {
+            }
+            // Build session-specific headers
+            const sessionHeaders = {};
+            // Use session CompanyID - handle both uppercase and lowercase
+            const companyId = sessionData?.user?.CompanyID || sessionData?.user?.companyID;
+            if (!companyId) {
+                console.error('❌ [APIClient] CompanyID not found in session:', {
+                    hasSessionData: !!sessionData,
+                    hasUser: !!sessionData?.user,
+                    userKeys: sessionData?.user ? Object.keys(sessionData.user) : []
+                });
+                throw new Error('CompanyID not found in session. Please login again.');
+            }
+            sessionHeaders['CompanyID'] = companyId.toString();
+            // Use session UserID - handle both uppercase and lowercase
+            const userId = sessionData?.user?.UserID || sessionData?.user?.userID;
+            if (!userId) {
+                console.error('❌ [APIClient] UserID not found in session:', {
+                    hasSessionData: !!sessionData,
+                    hasUser: !!sessionData?.user,
+                    userKeys: sessionData?.user ? Object.keys(sessionData.user) : []
+                });
+                throw new Error('UserID not found in session. Please login again.');
+            }
+            sessionHeaders['UserID'] = userId.toString();
+            // Add ProductionUnitID header - REQUIRED
+            // ALWAYS use session's ProductionUnitID in headers (logged-in user's production unit)
+            // Form-selected ProductionUnitID should be sent in the request body/payload separately
+            const productionUnitId = sessionData?.productionUnitId ||
+                sessionData?.user?.ProductionUnitID ||
+                sessionData?.user?.productionUnitID;
+            if (!productionUnitId) {
+                console.error('❌ [APIClient] ProductionUnitID not found in session:', {
+                    hasSessionData: !!sessionData,
+                    hasUser: !!sessionData?.user,
+                    userKeys: sessionData?.user ? Object.keys(sessionData.user) : []
+                });
+                throw new Error('ProductionUnitID not found in session. Please login again.');
+            }
+            sessionHeaders['ProductionUnitID'] = productionUnitId.toString();
+            // Add Financial Year header - REQUIRED (format: "2025-2026")
+            const fYear = sessionData?.fYear || sessionData?.user?.FYear || sessionData?.user?.fYear;
+            if (!fYear) {
+                console.error('❌ [APIClient] FYear not found in session:', {
+                    hasSessionData: !!sessionData,
+                    hasUser: !!sessionData?.user,
+                    userKeys: sessionData?.user ? Object.keys(sessionData.user) : []
+                });
+                throw new Error('FYear not found in session. Please login again.');
+            }
+            sessionHeaders['FYear'] = fYear;
+            // Merge headers
+            const headers = {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'Cache-Control': 'no-cache, no-store, must-revalidate', // Prevent caching
+                'Pragma': 'no-cache', // HTTP/1.0 compatibility
+                'Expires': '0', // Proxies
+                ...sessionHeaders,
+                ...(options.headers || {})
+            };
+            // Add Authorization header only if it exists
+            if (authHeader) {
+                headers['Authorization'] = authHeader;
+            }
+            // Per-call timeoutMs overrides the config default. Long-running workloads
+            // (chat, multi-turn AI) need to pass an explicit higher value — the 60s
+            // default aborts legit requests mid-flight and leaves half-finished turns.
+            const configData = getGlobalAPIConfig();
+            const timeout = timeoutMs ?? configData?.timeout ?? 60000;
+            // If caller passed an external signal (user cancel), combine with the timeout
+            // signal so either can cancel the fetch.
+            const timeoutSignal = AbortSignal.timeout(timeout);
+            const signal = externalSignal
+                ? AbortSignal.any?.([timeoutSignal, externalSignal]) ?? timeoutSignal
+                : timeoutSignal;
+            const startedAt = Date.now();
+            const response = await fetch(url, {
+                ...options,
+                headers,
+                signal,
+                cache: 'no-store' // Disable HTTP caching - always fetch fresh data
+            });
+            globalThis.__reportRequestMs?.(Date.now() - startedAt);
+            // Handle non-OK responses
+            if (!response.ok) {
+                let errorMessage = `API error: ${response.status} ${response.statusText}`;
+                try {
+                    const errorText = await response.text();
+                    if (errorText) {
+                        errorMessage = errorText;
+                    }
+                }
+                catch {
+                    // Use default error message if can't parse response
+                }
+                // Only auto-logout on explicit session expiry messages, NOT on generic 401s
+                // A 401 could mean the endpoint doesn't exist or requires different auth — not necessarily session expired
+                const lowerErr = errorMessage.toLowerCase();
+                if (lowerErr.includes('session not found') || lowerErr.includes('session expired')) {
+                    handleSessionExpired();
+                    return { success: false, error: 'Session expired. Redirecting to login...', status: response.status };
+                }
+                if (response.status === 401) {
+                    return { success: false, error: errorMessage || 'Unauthorized', status: 401 };
+                }
+                return {
+                    success: false,
+                    error: errorMessage,
+                    status: response.status
+                };
+            }
+            // Parse response
+            let data;
+            try {
+                const responseText = await response.text();
+                if (responseText && responseText.trim() !== '') {
+                    // Use safeJSONParse to handle double/triple encoding automatically
+                    data = safeJSONParse(responseText);
+                }
+            }
+            catch (parseError) {
+                // If JSON parsing fails, return error
+                return {
+                    success: false,
+                    error: 'Failed to parse API response',
+                    status: response.status
+                };
+            }
+            // Capture useful response headers (opt-in)
+            const responseHeaders = {};
+            const userMsgId = response.headers.get('X-User-MessageID');
+            if (userMsgId)
+                responseHeaders['X-User-MessageID'] = userMsgId;
+            const convId = response.headers.get('X-Conversation-ID');
+            if (convId)
+                responseHeaders['X-Conversation-ID'] = convId;
+            // Natural-sort production-unit list responses by name so every dropdown is consistent.
+            if (Array.isArray(data) && /productionunit/i.test(endpoint)) {
+                const nameOf = (r) => String(r?.ProductionUnitName ?? r?.productionUnitName ?? r?.PlantName ?? r?.plantName ?? r?.Name ?? r?.name ?? '');
+                const c = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+                data = [...data].sort((a, b) => c.compare(nameOf(a), nameOf(b)));
+            }
+            return {
+                success: true,
+                data,
+                status: response.status,
+                responseHeaders: Object.keys(responseHeaders).length > 0 ? responseHeaders : undefined
+            };
+        }
+        catch (error) {
+            // Handle network errors and timeouts
+            let errorMessage = 'Unable to complete request. Please try again.';
+            if (error instanceof Error) {
+                // AbortSignal.timeout() throws a TimeoutError (not AbortError); a caller-cancelled
+                // request throws AbortError. Both land here — distinguish by the external signal.
+                const isTimeout = error.name === 'TimeoutError' || error.message.toLowerCase().includes('timed out');
+                if (error.name === 'AbortError' || isTimeout) {
+                    // If the caller's own signal fired, surface a clean "aborted" signal so callers can detect user cancel.
+                    if (externalSignal?.aborted) {
+                        return { success: false, error: 'aborted', aborted: true };
+                    }
+                    errorMessage = 'Request timed out. The server is taking too long to respond. Please check your internet connection and try again.';
+                }
+                else if (error.message.includes('fetch') || error.message.includes('Failed to fetch')) {
+                    errorMessage = 'Unable to connect to server. Please check your internet connection and try again.';
+                }
+                else if (error.message.includes('NetworkError')) {
+                    errorMessage = 'Network connection lost. Please check your internet connection and try again.';
+                }
+                else if (error.message.includes('Session outdated') || error.message.includes('not found in session')) {
+                    handleSessionExpired();
+                    errorMessage = 'Session expired. Redirecting to login...';
+                }
+                else {
+                    errorMessage = error.message;
+                }
+            }
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Make a GET request
+     */
+    static async get(endpoint, sessionData, baseURLOverride) {
+        return this.request(endpoint, { method: 'GET' }, sessionData, baseURLOverride);
+    }
+    /**
+     * Make a POST request
+     */
+    static async post(endpoint, data, sessionData, baseURLOverride, signal, timeoutMs) {
+        return this.request(endpoint, {
+            method: 'POST',
+            body: data ? JSON.stringify(data) : undefined
+        }, sessionData, baseURLOverride, signal, timeoutMs);
+    }
+    /**
+     * Make a PUT request
+     */
+    static async put(endpoint, data, sessionData, baseURLOverride) {
+        return this.request(endpoint, {
+            method: 'PUT',
+            body: data ? JSON.stringify(data) : undefined
+        }, sessionData, baseURLOverride);
+    }
+    /**
+     * Make a DELETE request
+     */
+    static async delete(endpoint, sessionData, baseURLOverride) {
+        return this.request(endpoint, { method: 'DELETE' }, sessionData, baseURLOverride);
+    }
+    /**
+     * Make a PATCH request
+     */
+    static async patch(endpoint, data, sessionData) {
+        return this.request(endpoint, {
+            method: 'PATCH',
+            body: data ? JSON.stringify(data) : undefined
+        }, sessionData);
+    }
+}
+export default APIClient;

package/dist/lib/api/core/config.d.ts

@@ -0,0 +1,46 @@
+import type { APIConfig } from './types.js';
+export interface StoredAPIConfig {
+    baseURL: string;
+    username: string;
+    password: string;
+    authToken: string;
+    timeout: number;
+    lastUpdated: string;
+}
+/**
+ * Set the global API configuration
+ * This will be used for all API calls across the application
+ */
+export declare function setGlobalAPIConfig(config: APIConfig): void;
+/**
+ * Get the current global API configuration
+ * Returns null if not configured
+ */
+export declare function getGlobalAPIConfig(): StoredAPIConfig | null;
+/**
+ * Clear the global API configuration
+ */
+export declare function clearGlobalAPIConfig(): void;
+/**
+ * Check if API is configured
+ */
+export declare function isAPIConfigured(): boolean;
+/**
+ * Get Basic Auth header for the current configuration
+ */
+export declare function getBasicAuthHeader(): string | null;
+/**
+ * Build a complete API URL from a relative endpoint
+ * @param endpoint - Relative endpoint (e.g., 'api/GetLoginDetails')
+ * @returns Complete URL or null if not configured
+ */
+export declare function buildAPIURL(endpoint: string): string | null;
+/**
+ * Get default fetch options with Basic Auth header
+ */
+export declare function getDefaultAPIOptions(): RequestInit | null;
+/**
+ * Initialize API configuration automatically from environment variables
+ * This should be called once when the app starts
+ */
+export declare function initializeAPI(): boolean;

package/dist/lib/api/core/config.js

@@ -0,0 +1,238 @@
+'use client';
+// Global API Configuration System
+// Store once, use everywhere
+// Default configuration from environment variables
+// Note: username/password are set dynamically during login from session
+const getDefaultConfig = () => ({
+    baseURL: process.env.NEXT_PUBLIC_API_BASE_URL || '',
+    username: '', // Set during login from session
+    password: '', // Set during login from session
+    timeout: 60000 // 60 seconds for complex planning calculations
+});
+// Global configuration state
+let globalConfig = null;
+// Storage keys
+const CONFIG_STORAGE_KEY = 'api-global-config';
+const CONFIG_STORAGE_KEY_ENCRYPTED = 'api-global-config-enc';
+// Simple encryption for stored credentials (browser only)
+const encryptCredentials = (data) => {
+    if (typeof window === 'undefined')
+        return data;
+    try {
+        return btoa(data);
+    }
+    catch {
+        return data;
+    }
+};
+const decryptCredentials = (data) => {
+    if (typeof window === 'undefined')
+        return data;
+    try {
+        return atob(data);
+    }
+    catch {
+        return data;
+    }
+};
+/**
+ * Set the global API configuration
+ * This will be used for all API calls across the application
+ */
+export function setGlobalAPIConfig(config) {
+    // Validate configuration
+    if (!config.baseURL) {
+        throw new Error('Base URL is required for API configuration');
+    }
+    // With multi-tenant, username/password are optional (set during login)
+    // Legacy: Still validate if both are provided or both are empty
+    if ((!config.username && config.password) || (config.username && !config.password)) {
+        throw new Error('Username and password must both be provided or both be empty');
+    }
+    // Validate URL format
+    try {
+        new URL(config.baseURL);
+    }
+    catch {
+        throw new Error('Invalid base URL format');
+    }
+    // Ensure base URL ends with /
+    const normalizedBaseURL = config.baseURL.endsWith('/')
+        ? config.baseURL
+        : config.baseURL + '/';
+    // Pre-compute the Basic Auth token so raw password doesn't need to be stored
+    let authToken = '';
+    if (config.username && config.password) {
+        try {
+            authToken = btoa(`${config.username}:${config.password}`);
+        }
+        catch {
+            // Silent fail
+        }
+    }
+    const storedConfig = {
+        baseURL: normalizedBaseURL,
+        username: config.username,
+        password: '', // Don't persist raw password in memory
+        authToken,
+        timeout: config.timeout || 60000,
+        lastUpdated: new Date().toISOString()
+    };
+    globalConfig = storedConfig;
+    // Store configuration securely (browser only)
+    if (typeof window !== 'undefined') {
+        try {
+            // Store non-sensitive data in regular storage
+            const publicConfig = {
+                baseURL: storedConfig.baseURL,
+                timeout: storedConfig.timeout,
+                lastUpdated: storedConfig.lastUpdated
+            };
+            sessionStorage.setItem(CONFIG_STORAGE_KEY, JSON.stringify(publicConfig));
+            // Store only the pre-computed auth token, not the raw password
+            const sensitiveConfig = {
+                username: storedConfig.username,
+                authToken: storedConfig.authToken
+            };
+            const encryptedCredentials = encryptCredentials(JSON.stringify(sensitiveConfig));
+            sessionStorage.setItem(CONFIG_STORAGE_KEY_ENCRYPTED, encryptedCredentials);
+        }
+        catch (error) {
+            // Silent fail for storage errors
+        }
+    }
+}
+/**
+ * Get the current global API configuration
+ * Returns null if not configured
+ */
+export function getGlobalAPIConfig() {
+    if (globalConfig) {
+        return globalConfig;
+    }
+    // Try to restore from storage (browser only)
+    if (typeof window !== 'undefined') {
+        try {
+            const publicConfigStr = sessionStorage.getItem(CONFIG_STORAGE_KEY);
+            const encryptedCredentials = sessionStorage.getItem(CONFIG_STORAGE_KEY_ENCRYPTED);
+            if (publicConfigStr && encryptedCredentials) {
+                const publicConfig = JSON.parse(publicConfigStr);
+                const sensitiveConfig = JSON.parse(decryptCredentials(encryptedCredentials));
+                // Compute auth token: use stored token if available, fall back to legacy password for old sessions
+                let authToken = sensitiveConfig.authToken || '';
+                if (!authToken && sensitiveConfig.username && sensitiveConfig.password) {
+                    try {
+                        authToken = btoa(`${sensitiveConfig.username}:${sensitiveConfig.password}`);
+                    }
+                    catch { }
+                }
+                globalConfig = {
+                    ...publicConfig,
+                    username: sensitiveConfig.username || '',
+                    password: '', // Never restore raw password
+                    authToken
+                };
+                return globalConfig;
+            }
+        }
+        catch (error) {
+            clearGlobalAPIConfig();
+        }
+    }
+    // Do NOT auto-initialize from environment variables
+    // Credentials are set during login from session (multi-tenant mode)
+    // This prevents authentication failures
+    return null;
+}
+/**
+ * Clear the global API configuration
+ */
+export function clearGlobalAPIConfig() {
+    globalConfig = null;
+    if (typeof window !== 'undefined') {
+        sessionStorage.removeItem(CONFIG_STORAGE_KEY);
+        sessionStorage.removeItem(CONFIG_STORAGE_KEY_ENCRYPTED);
+    }
+}
+/**
+ * Check if API is configured
+ */
+export function isAPIConfigured() {
+    return getGlobalAPIConfig() !== null;
+}
+/**
+ * Get Basic Auth header for the current configuration
+ */
+export function getBasicAuthHeader() {
+    const config = getGlobalAPIConfig();
+    if (!config)
+        return null;
+    // Use pre-computed auth token — raw password is never stored
+    if (config.authToken) {
+        return `Basic ${config.authToken}`;
+    }
+    return null;
+}
+/**
+ * Build a complete API URL from a relative endpoint
+ * @param endpoint - Relative endpoint (e.g., 'api/GetLoginDetails')
+ * @returns Complete URL or null if not configured
+ */
+export function buildAPIURL(endpoint) {
+    const config = getGlobalAPIConfig();
+    if (!config) {
+        return null;
+    }
+    // Remove leading slash from endpoint if present
+    const cleanEndpoint = endpoint.startsWith('/') ? endpoint.slice(1) : endpoint;
+    // Ensure baseURL ends with slash
+    const baseURL = config.baseURL.endsWith('/') ? config.baseURL : `${config.baseURL}/`;
+    const fullURL = `${baseURL}${cleanEndpoint}`;
+    return fullURL;
+}
+/**
+ * Get default fetch options with Basic Auth header
+ */
+export function getDefaultAPIOptions() {
+    const config = getGlobalAPIConfig();
+    if (!config)
+        return null;
+    const authHeader = getBasicAuthHeader();
+    if (!authHeader)
+        return null;
+    return {
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'Authorization': authHeader
+        },
+        signal: AbortSignal.timeout(config.timeout)
+    };
+}
+// API Initialization flag
+let isInitialized = false;
+/**
+ * Initialize API configuration automatically from environment variables
+ * This should be called once when the app starts
+ */
+export function initializeAPI() {
+    if (isInitialized)
+        return true;
+    try {
+        // Check if already configured
+        if (isAPIConfigured()) {
+            isInitialized = true;
+            return true;
+        }
+        // Get configuration (getGlobalAPIConfig will auto-load from env)
+        const config = getGlobalAPIConfig();
+        if (config) {
+            isInitialized = true;
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/dist/lib/api/core/index.d.ts

@@ -0,0 +1,6 @@
+export { default as APIClient } from './client.js';
+export { default } from './client.js';
+export { setGlobalAPIConfig, getGlobalAPIConfig, clearGlobalAPIConfig, isAPIConfigured, getBasicAuthHeader, buildAPIURL, getDefaultAPIOptions, initializeAPI, type StoredAPIConfig } from './config.js';
+export { loginAPI, pingAPI } from './auth-helpers.js';
+export * from './utils.js';
+export type { APIResponse, APIConfig, Category, Client, SalesPerson, Quality, GSMData, MillData, FinishData, BoardBrandData, CoatingData, MachineData, LoginRequest, UserData, LoginResponse } from './types.js';

package/dist/lib/api/core/index.js

@@ -0,0 +1,11 @@
+'use client';
+// Core API exports
+// Central export point for all core API utilities
+// Export APIClient as both named and default export
+export { default as APIClient } from './client.js';
+export { default } from './client.js';
+// Export configuration functions
+export { setGlobalAPIConfig, getGlobalAPIConfig, clearGlobalAPIConfig, isAPIConfigured, getBasicAuthHeader, buildAPIURL, getDefaultAPIOptions, initializeAPI } from './config.js';
+// Export auth helpers
+export { loginAPI, pingAPI } from './auth-helpers.js';
+export * from './utils.js';

package/dist/lib/api/core/session-validator.d.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from 'next/server';
+import type { Session } from 'next-auth';
+/**
+ * Result of session validation
+ */
+interface SessionValidationResult {
+    valid: boolean;
+    session?: Session;
+    response?: NextResponse;
+}
+/**
+ * Validate session for API routes
+ * Checks if session exists and is not expired
+ *
+ * @returns SessionValidationResult with session if valid, or error response if invalid
+ *
+ * @example
+ * ```typescript
+ * export async function POST(req: NextRequest) {
+ *   const validation = await validateSession()
+ *   if (!validation.valid) return validation.response!
+ *
+ *   const { session } = validation
+ *   // ... rest of API logic using session
+ * }
+ * ```
+ */
+export declare function validateSession(): Promise<SessionValidationResult>;
+/**
+ * Validate session and extract user data
+ * Convenience function that returns user data directly
+ *
+ * @returns User data if session valid, or error response if invalid
+ *
+ * @example
+ * ```typescript
+ * export async function POST(req: NextRequest) {
+ *   const result = await validateSessionAndGetUser()
+ *   if ('response' in result) return result.response
+ *
+ *   const { user, session } = result
+ *   // ... rest of API logic using user and session
+ * }
+ * ```
+ */
+export declare function validateSessionAndGetUser(): Promise<{
+    response: NextResponse<unknown>;
+    user?: undefined;
+    session?: undefined;
+} | {
+    user: import("next-auth").User;
+    session: Session;
+    response?: undefined;
+}>;
+export {};