indas-ui 0.0.1 → 0.1.0

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

@@ -0,0 +1 @@
+export { fetchDynamicMenuModules, groupAndSortModules, getDynamicNavigation, type DynamicModule, type GroupedModule } from './menu.js';

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

@@ -0,0 +1,5 @@
+'use client';
+// Utility API exports
+// Central export point for all utility APIs
+// Export menu API
+export { fetchDynamicMenuModules, groupAndSortModules, getDynamicNavigation } from './menu.js';

package/dist/lib/api/utility/menu.d.ts

@@ -0,0 +1,32 @@
+export interface DynamicModule {
+    ModuleHeadName: string;
+    ModuleDisplayName: string;
+    SetGroupIndex: number;
+    NumberOfChild: number;
+    ModuleName: string;
+    ModuleDisplayOrder: number;
+    ParentModuleName?: string;
+    children?: DynamicModule[];
+    MobileSupported?: number | boolean;
+    IconName?: string;
+    IsIntegrationRequired?: number | boolean;
+}
+export interface GroupedModule {
+    groupName: string;
+    modules: DynamicModule[];
+    groupIndex: number;
+}
+/**
+ * Fetch dynamic menu modules from external API
+ * Now uses APIClient for proper authentication with company credentials
+ */
+export declare function fetchDynamicMenuModules(companyId: number, userId: number): Promise<DynamicModule[]>;
+/**
+ * Group modules by ModuleHeadName and sort by ModuleDisplayOrder
+ * Now supports hierarchical sub-modules
+ */
+export declare function groupAndSortModules(modules: DynamicModule[]): GroupedModule[];
+/**
+ * Get dynamic navigation structure for sidebar
+ */
+export declare function getDynamicNavigation(companyId?: number, userId?: number): Promise<GroupedModule[]>;

package/dist/lib/api/utility/menu.js

@@ -0,0 +1,128 @@
+'use client';
+// Dynamic Menu API
+// Handles dynamic menu and navigation
+import APIClient from '../core/client.js';
+import { getSession } from 'next-auth/react';
+/**
+ * Fetch dynamic menu modules from external API
+ * Now uses APIClient for proper authentication with company credentials
+ */
+export async function fetchDynamicMenuModules(companyId, userId) {
+    try {
+        // Get session to pass to APIClient for company credentials
+        const session = await getSession();
+        if (!session) {
+            return [];
+        }
+        // Use APIClient which handles company credentials from session
+        const response = await APIClient.get('api/othermaster/createdynamicmenuwithsubmenu', session);
+        if (!response.success || !response.data) {
+            return [];
+        }
+        const data = response.data;
+        // Handle different response formats
+        let parsedData = data;
+        // Handle multiple levels of JSON encoding
+        if (typeof data === 'string') {
+            try {
+                parsedData = JSON.parse(data);
+                // If still a string, parse again (triple-encoded JSON)
+                if (typeof parsedData === 'string') {
+                    parsedData = JSON.parse(parsedData);
+                }
+            }
+            catch (parseError) {
+                return [];
+            }
+        }
+        // Handle the response structure - might be wrapped in a success object
+        if (Array.isArray(parsedData)) {
+            return parsedData;
+        }
+        else if (parsedData.data && Array.isArray(parsedData.data)) {
+            return parsedData.data;
+        }
+        else if (parsedData.success && parsedData.data && Array.isArray(parsedData.data)) {
+            return parsedData.data;
+        }
+        return [];
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Build hierarchical structure for modules with children
+ */
+function buildModuleHierarchy(modules) {
+    // Create a map for quick lookup
+    const moduleMap = new Map();
+    const rootModules = [];
+    // First pass: create module map
+    modules.forEach(module => {
+        moduleMap.set(module.ModuleName, { ...module, children: [] });
+    });
+    // Second pass: build hierarchy
+    modules.forEach(module => {
+        const currentModule = moduleMap.get(module.ModuleName);
+        if (!currentModule)
+            return;
+        if (module.ParentModuleName && moduleMap.has(module.ParentModuleName)) {
+            // This is a child module, add to parent's children
+            const parent = moduleMap.get(module.ParentModuleName);
+            if (parent && parent.children) {
+                parent.children.push(currentModule);
+            }
+        }
+        else {
+            // This is a root module
+            rootModules.push(currentModule);
+        }
+    });
+    // Sort children by display order
+    const sortChildren = (module) => {
+        if (module.children && module.children.length > 0) {
+            module.children.sort((a, b) => a.ModuleDisplayOrder - b.ModuleDisplayOrder);
+            module.children.forEach(sortChildren);
+        }
+    };
+    rootModules.forEach(sortChildren);
+    return rootModules.sort((a, b) => a.ModuleDisplayOrder - b.ModuleDisplayOrder);
+}
+/**
+ * Group modules by ModuleHeadName and sort by ModuleDisplayOrder
+ * Now supports hierarchical sub-modules
+ */
+export function groupAndSortModules(modules) {
+    // Group by ModuleHeadName
+    const grouped = modules.reduce((acc, module) => {
+        const groupName = module.ModuleHeadName;
+        if (!acc[groupName]) {
+            acc[groupName] = {
+                modules: [],
+                groupIndex: module.SetGroupIndex
+            };
+        }
+        acc[groupName].modules.push(module);
+        return acc;
+    }, {});
+    // Convert to array, build hierarchy, and sort
+    return Object.entries(grouped)
+        .map(([groupName, { modules, groupIndex }]) => ({
+        groupName,
+        modules: buildModuleHierarchy(modules),
+        groupIndex
+    }))
+        // Sort groups by SetGroupIndex
+        .sort((a, b) => a.groupIndex - b.groupIndex);
+}
+/**
+ * Get dynamic navigation structure for sidebar
+ */
+export async function getDynamicNavigation(companyId, userId) {
+    if (!companyId || !userId) {
+        return [];
+    }
+    const modules = await fetchDynamicMenuModules(companyId, userId);
+    return groupAndSortModules(modules);
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,3 @@
+import { authOptions } from "@/pages/api/auth/[...nextauth]";
+export declare const getServerAuthSession: () => Promise<import("next-auth").Session>;
+export { authOptions };

package/dist/lib/auth.js

@@ -0,0 +1,7 @@
+import { getServerSession } from "next-auth/next";
+import { authOptions } from "@/pages/api/auth/[...nextauth]";
+export const getServerAuthSession = () => {
+    return getServerSession(authOptions);
+};
+// Export auth options for use in other parts of the app
+export { authOptions };

package/dist/lib/pwa.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PWA utilities — service worker registration, push notifications, and registrar component.
+ */
+export declare function registerServiceWorker(): Promise<ServiceWorkerRegistration>;
+export declare function subscribeToPush(): Promise<PushSubscription | null>;
+export declare function isPushSupported(): boolean;
+/** Drop into layout — registers SW on mount */
+export declare function PWARegistrar(): any;

package/dist/lib/pwa.js

@@ -0,0 +1,53 @@
+'use client';
+import { useEffect } from 'react';
+/**
+ * PWA utilities — service worker registration, push notifications, and registrar component.
+ */
+export async function registerServiceWorker() {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
+        return null;
+    }
+    try {
+        const registration = await navigator.serviceWorker.register('/sw.js', { scope: '/' });
+        return registration;
+    }
+    catch {
+        return null;
+    }
+}
+export async function subscribeToPush() {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator) || !('PushManager' in window)) {
+        return null;
+    }
+    try {
+        const permission = await Notification.requestPermission();
+        if (permission !== 'granted') {
+            return null;
+        }
+        const registration = await navigator.serviceWorker.ready;
+        const existing = await registration.pushManager.getSubscription();
+        if (existing) {
+            return existing;
+        }
+        // VAPID public key needed when backend endpoint is ready
+        // const subscription = await registration.pushManager.subscribe({
+        //   userVisibleOnly: true,
+        //   applicationServerKey: process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY,
+        // })
+        // return subscription
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isPushSupported() {
+    return typeof window !== 'undefined' && 'serviceWorker' in navigator && 'PushManager' in window;
+}
+/** Drop into layout — registers SW on mount */
+export function PWARegistrar() {
+    useEffect(() => {
+        registerServiceWorker();
+    }, []);
+    return null;
+}

package/dist/lib/react-query-config.d.ts

@@ -0,0 +1,140 @@
+/**
+ * React Query Config
+ *
+ * Controls when data is refetched and how long it's cached.
+ *
+ * KEY CONCEPTS:
+ *
+ * 1. STALE TIME (Fresh Time)
+ *    - How long data is considered "fresh" before it needs to be refetched
+ *    - Example: 10m means data stays fresh for 10 minutes
+ *    - During this time, React Query won't refetch even if you remount the component
+ *
+ * 2. GC TIME (Cache Time / Garbage Collection Time)
+ *    - How long unused data stays in memory before being deleted
+ *    - Example: 30m means cached data is kept for 30 minutes after last use
+ *    - Helps with instant navigation when returning to previously visited pages
+ *
+ * 3. RETRY
+ *    - How many times to retry a failed request
+ *    - Example: retry: 1 means try once more if the first attempt fails
+ *
+ * SIMPLE RULE:
+ * - Stale Time = "How fresh is my data?"
+ * - GC Time = "How long do I remember it?"
+ * - Retry = "How many times do I try again if it fails?"
+ */
+export declare const QueryConfig: {
+    /**
+     * REALTIME - Live monitoring (10s fresh, 5m cache, retry 3x)
+     * Use for: Chat, notifications, live production monitoring, real-time dashboards
+     */
+    readonly REALTIME: {
+        readonly staleTime: number;
+        readonly gcTime: number;
+        readonly refetchOnMount: "always";
+        readonly refetchOnWindowFocus: true;
+        readonly refetchOnReconnect: true;
+        readonly retry: 3;
+        readonly retryDelay: (attemptIndex: any) => number;
+    };
+    /**
+     * FREQUENT - Short-lived freshness (1m fresh, 10m cache, retry 1x)
+     * Use for: Dropdowns, selectors, form options that may change during a session
+     */
+    readonly FREQUENT: {
+        readonly staleTime: number;
+        readonly gcTime: number;
+        readonly refetchOnMount: false;
+        readonly refetchOnWindowFocus: false;
+        readonly refetchOnReconnect: false;
+        readonly retry: 1;
+        readonly retryDelay: 2000;
+    };
+    /**
+     * MODERATE - Updates occasionally (5m fresh, 20m cache, retry 1x)
+     * Use for: Reports, analytics, approval queues, dashboard metrics
+     */
+    readonly MODERATE: {
+        readonly staleTime: number;
+        readonly gcTime: number;
+        readonly refetchOnMount: false;
+        readonly refetchOnWindowFocus: false;
+        readonly refetchOnReconnect: false;
+        readonly retry: 1;
+        readonly retryDelay: 2000;
+    };
+    /**
+     * STANDARD - Default for master pages (10m fresh, 30m cache, retry 1x)
+     * Use for: User, Item, Machine, Process, Ledger masters
+     */
+    readonly STANDARD: {
+        readonly staleTime: number;
+        readonly gcTime: number;
+        readonly refetchOnMount: false;
+        readonly refetchOnWindowFocus: false;
+        readonly refetchOnReconnect: false;
+        readonly retry: 1;
+        readonly retryDelay: 2000;
+    };
+    /**
+     * STATIC - Rarely changing data (30m fresh, 2h cache, retry 1x)
+     * Use for: Dropdowns, currencies, departments, branches
+     */
+    readonly STATIC: {
+        readonly staleTime: number;
+        readonly gcTime: number;
+        readonly refetchOnMount: false;
+        readonly refetchOnWindowFocus: false;
+        readonly refetchOnReconnect: false;
+        readonly retry: 1;
+        readonly retryDelay: 3000;
+    };
+    /**
+     * PERMANENT - Never changes (forever fresh, 2h cache, no retry)
+     * Use for: App config, feature flags, company settings
+     */
+    readonly PERMANENT: {
+        readonly staleTime: number;
+        readonly gcTime: number;
+        readonly refetchOnMount: false;
+        readonly refetchOnWindowFocus: false;
+        readonly refetchOnReconnect: false;
+        readonly retry: 0;
+    };
+};
+/** Type for QueryConfig values */
+export type QueryConfigType = typeof QueryConfig[keyof typeof QueryConfig];
+/**
+ * Default config applied to all queries globally
+ */
+export declare const DEFAULT_QUERY_CONFIG: {
+    readonly staleTime: number;
+    readonly gcTime: number;
+    readonly refetchOnMount: false;
+    readonly refetchOnWindowFocus: false;
+    readonly refetchOnReconnect: false;
+    readonly retry: 1;
+    readonly retryDelay: 2000;
+};
+/**
+ * QUICK REFERENCE
+ *
+ * | Config    | Fresh   | Cache | Auto Refresh? | Retry | Use For                      |
+ * |-----------|---------|-------|---------------|-------|------------------------------|
+ * | REALTIME  | 10s     | 5m    | YES           | 3x    | Chat, live monitoring        |
+ * | FREQUENT  | 1m      | 10m   | NO            | 1x    | Dropdowns, selectors, forms  |
+ * | MODERATE  | 5m      | 20m   | NO            | 1x    | Reports, dashboards          |
+ * | STANDARD  | 10m     | 30m   | NO            | 1x    | Master pages (default)       |
+ * | STATIC    | 30m     | 2h    | NO            | 1x    | Currencies, departments      |
+ * | PERMANENT | Forever | 2h    | NO            | 0x    | App config, settings         |
+ *
+ * USAGE:
+ * import { QueryConfig } from './react-query-config.js'
+ *
+ * useQuery({
+ *   queryKey: ['users'],
+ *   queryFn: getUsersAPI,
+ *   ...QueryConfig.STANDARD,
+ * })
+ */

package/dist/lib/react-query-config.js

@@ -0,0 +1,131 @@
+'use client';
+/**
+ * React Query Config
+ *
+ * Controls when data is refetched and how long it's cached.
+ *
+ * KEY CONCEPTS:
+ *
+ * 1. STALE TIME (Fresh Time)
+ *    - How long data is considered "fresh" before it needs to be refetched
+ *    - Example: 10m means data stays fresh for 10 minutes
+ *    - During this time, React Query won't refetch even if you remount the component
+ *
+ * 2. GC TIME (Cache Time / Garbage Collection Time)
+ *    - How long unused data stays in memory before being deleted
+ *    - Example: 30m means cached data is kept for 30 minutes after last use
+ *    - Helps with instant navigation when returning to previously visited pages
+ *
+ * 3. RETRY
+ *    - How many times to retry a failed request
+ *    - Example: retry: 1 means try once more if the first attempt fails
+ *
+ * SIMPLE RULE:
+ * - Stale Time = "How fresh is my data?"
+ * - GC Time = "How long do I remember it?"
+ * - Retry = "How many times do I try again if it fails?"
+ */
+export const QueryConfig = {
+    /**
+     * REALTIME - Live monitoring (10s fresh, 5m cache, retry 3x)
+     * Use for: Chat, notifications, live production monitoring, real-time dashboards
+     */
+    REALTIME: {
+        staleTime: 10 * 1000, // Fresh: 10 seconds
+        gcTime: 5 * 60 * 1000, // Cache: 5 minutes
+        refetchOnMount: 'always',
+        refetchOnWindowFocus: true,
+        refetchOnReconnect: true,
+        retry: 3, // Retry 3 times (critical)
+        retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 5000),
+    },
+    /**
+     * FREQUENT - Short-lived freshness (1m fresh, 10m cache, retry 1x)
+     * Use for: Dropdowns, selectors, form options that may change during a session
+     */
+    FREQUENT: {
+        staleTime: 60 * 1000, // Fresh: 1 minute
+        gcTime: 10 * 60 * 1000, // Cache: 10 minutes
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
+        retry: 1,
+        retryDelay: 2000,
+    },
+    /**
+     * MODERATE - Updates occasionally (5m fresh, 20m cache, retry 1x)
+     * Use for: Reports, analytics, approval queues, dashboard metrics
+     */
+    MODERATE: {
+        staleTime: 5 * 60 * 1000, // Fresh: 5 minutes
+        gcTime: 20 * 60 * 1000, // Cache: 20 minutes
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
+        retry: 1, // Retry once
+        retryDelay: 2000, // Fixed 2s delay
+    },
+    /**
+     * STANDARD - Default for master pages (10m fresh, 30m cache, retry 1x)
+     * Use for: User, Item, Machine, Process, Ledger masters
+     */
+    STANDARD: {
+        staleTime: 10 * 60 * 1000, // Fresh: 10 minutes
+        gcTime: 30 * 60 * 1000, // Cache: 30 minutes
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
+        retry: 1, // Retry once
+        retryDelay: 2000, // Fixed 2s delay
+    },
+    /**
+     * STATIC - Rarely changing data (30m fresh, 2h cache, retry 1x)
+     * Use for: Dropdowns, currencies, departments, branches
+     */
+    STATIC: {
+        staleTime: 30 * 60 * 1000, // Fresh: 30 minutes
+        gcTime: 2 * 60 * 60 * 1000, // Cache: 2 hours
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
+        retry: 1, // Retry once
+        retryDelay: 3000, // Fixed 3s delay
+    },
+    /**
+     * PERMANENT - Never changes (forever fresh, 2h cache, no retry)
+     * Use for: App config, feature flags, company settings
+     */
+    PERMANENT: {
+        staleTime: Infinity, // Fresh: Forever
+        gcTime: 2 * 60 * 60 * 1000, // Cache: 2 hours
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
+        retry: 0, // Don't retry (fail fast)
+    },
+};
+/**
+ * Default config applied to all queries globally
+ */
+export const DEFAULT_QUERY_CONFIG = QueryConfig.STANDARD;
+/**
+ * QUICK REFERENCE
+ *
+ * | Config    | Fresh   | Cache | Auto Refresh? | Retry | Use For                      |
+ * |-----------|---------|-------|---------------|-------|------------------------------|
+ * | REALTIME  | 10s     | 5m    | YES           | 3x    | Chat, live monitoring        |
+ * | FREQUENT  | 1m      | 10m   | NO            | 1x    | Dropdowns, selectors, forms  |
+ * | MODERATE  | 5m      | 20m   | NO            | 1x    | Reports, dashboards          |
+ * | STANDARD  | 10m     | 30m   | NO            | 1x    | Master pages (default)       |
+ * | STATIC    | 30m     | 2h    | NO            | 1x    | Currencies, departments      |
+ * | PERMANENT | Forever | 2h    | NO            | 0x    | App config, settings         |
+ *
+ * USAGE:
+ * import { QueryConfig } from './react-query-config.js'
+ *
+ * useQuery({
+ *   queryKey: ['users'],
+ *   queryFn: getUsersAPI,
+ *   ...QueryConfig.STANDARD,
+ * })
+ */

package/dist/lib/security/audit-logger.d.ts

@@ -0,0 +1,71 @@
+export interface AuditLogOptions {
+    /** Basic auth credentials — needed when logging before session exists (e.g. login events) */
+    basicAuth?: {
+        username: string;
+        password: string;
+    };
+}
+export interface AuditLog {
+    timestamp?: string;
+    event: 'LOGIN_SUCCESS' | 'LOGIN_FAILURE' | 'LOGOUT' | 'SESSION_EXPIRED' | 'RATE_LIMIT_EXCEEDED' | 'UNAUTHORIZED_ACCESS';
+    username?: string;
+    userId?: string;
+    companyId?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    metadata?: Record<string, any>;
+    success?: boolean;
+    errorMessage?: string;
+    loginTime?: string;
+    sessionDurationMinutes?: number;
+    attemptCount?: number;
+    failureReason?: string;
+}
+declare class AuditLogger {
+    private apiBaseUrl;
+    constructor();
+    /**
+     * Log a security event to backend database
+     */
+    log(event: AuditLog, options?: AuditLogOptions): Promise<void>;
+    /**
+     * Get recent logs from backend
+     */
+    getRecentLogs(limit?: number, options?: {
+        eventType?: string;
+        username?: string;
+        companyId?: string;
+    }): Promise<AuditLog[]>;
+    /**
+     * Get logs for a specific user
+     */
+    getUserLogs(username: string, limit?: number): Promise<AuditLog[]>;
+    /**
+     * Get logs for a specific event type
+     */
+    getEventLogs(event: AuditLog['event'], limit?: number): Promise<AuditLog[]>;
+    /**
+     * Get failed login attempts for a user
+     */
+    getFailedLoginAttempts(username: string, since?: Date): Promise<AuditLog[]>;
+    /**
+     * Get emoji for event type
+     */
+    private getEventEmoji;
+    /**
+     * Get statistics from backend
+     */
+    getStats(companyId?: string, startDate?: Date): Promise<{
+        totalLogs: number;
+        loginSuccesses: number;
+        loginFailures: number;
+        logouts: number;
+        rateLimitExceeded: number;
+        unauthorizedAccess: number;
+        uniqueUsers: number;
+        uniqueIPAddresses: number;
+    }>;
+}
+export declare const auditLogger: AuditLogger;
+export declare function getUserAgent(request: Request): string;
+export {};