indas-ui 0.0.1 → 0.1.0

package/dist/cjs/lib/api/core/session-validator.js

@@ -0,0 +1,98 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSession = validateSession;
+exports.validateSessionAndGetUser = validateSessionAndGetUser;
+const auth_1 = require("../../auth.js");
+const server_1 = require("next/server");
+/**
+ * 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
+ * }
+ * ```
+ */
+async function validateSession() {
+    try {
+        const session = await (0, auth_1.getServerAuthSession)();
+        // Check if session exists
+        if (!session || !session.user) {
+            return {
+                valid: false,
+                response: server_1.NextResponse.json({
+                    success: false,
+                    message: 'Session expired. Please login again.',
+                    error: 'UNAUTHORIZED'
+                }, { status: 401 })
+            };
+        }
+        // Check if session is expired
+        if (session.expires) {
+            const expiryTime = new Date(session.expires);
+            const now = new Date();
+            if (now >= expiryTime) {
+                return {
+                    valid: false,
+                    response: server_1.NextResponse.json({
+                        success: false,
+                        message: 'Session expired. Please login again.',
+                        error: 'SESSION_EXPIRED'
+                    }, { status: 401 })
+                };
+            }
+        }
+        // Session is valid
+        return {
+            valid: true,
+            session
+        };
+    }
+    catch (error) {
+        console.error('Session validation error:', error);
+        return {
+            valid: false,
+            response: server_1.NextResponse.json({
+                success: false,
+                message: 'Authentication error. Please try again.',
+                error: 'AUTH_ERROR'
+            }, { status: 500 })
+        };
+    }
+}
+/**
+ * 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
+ * }
+ * ```
+ */
+async function validateSessionAndGetUser() {
+    const validation = await validateSession();
+    if (!validation.valid) {
+        return { response: validation.response };
+    }
+    return {
+        user: validation.session.user,
+        session: validation.session
+    };
+}

package/dist/cjs/lib/api/core/types.js

@@ -0,0 +1,4 @@
+'use client';
+"use strict";
+// Shared API types and interfaces
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/api/core/utils.js

@@ -0,0 +1,70 @@
+'use client';
+"use strict";
+// Core API Utilities
+// Shared helper functions for API handling
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAPIError = exports.handleAPIResponse = exports.safeJSONParse = void 0;
+/**
+ * Safely parses a JSON string, handling multiple levels of encoding.
+ * Useful for APIs that return double or triple encoded JSON strings.
+ *
+ * @param data - The data to parse (string or any)
+ * @param fallback - Optional fallback value if parsing fails
+ * @returns Parsed object or original data if not a string/parseable
+ */
+const safeJSONParse = (data, fallback) => {
+    // If null or undefined, return fallback or data
+    if (data === null || data === undefined) {
+        return fallback !== undefined ? fallback : data;
+    }
+    // If not a string, return as is (assuming it's already an object)
+    if (typeof data !== 'string') {
+        return data;
+    }
+    // Try parsing
+    try {
+        const parsed = JSON.parse(data);
+        // Recursive check for nested encoding (common in some legacy .NET APIs)
+        if (typeof parsed === 'string') {
+            return (0, exports.safeJSONParse)(parsed, fallback);
+        }
+        return parsed;
+    }
+    catch (error) {
+        // Parsing failed, return fallback if provided, otherwise original string
+        return (fallback !== undefined ? fallback : data);
+    }
+};
+exports.safeJSONParse = safeJSONParse;
+const handleAPIResponse = (response, onSuccess, onError) => {
+    if (response.success) {
+        // Ensure data is parsed safely
+        const parsedData = (0, exports.safeJSONParse)(response.data);
+        if (parsedData) {
+            onSuccess?.(parsedData);
+        }
+        else {
+            // If data is null/undefined but success is true, still call onSuccess with empty/null
+            onSuccess?.(parsedData);
+        }
+    }
+    else {
+        const errorMessage = response.error || 'An unexpected error occurred';
+        onError?.(errorMessage);
+    }
+};
+exports.handleAPIResponse = handleAPIResponse;
+/**
+ * Helper to log API errors with consistent formatting
+ */
+const logAPIError = (context, error, details) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`❌ [${context}] Error:`, message);
+    if (details) {
+        console.error(`❌ [${context}] Details:`, details);
+    }
+    if (error instanceof Error && error.stack) {
+        console.debug(`❌ [${context}] Stack:`, error.stack);
+    }
+};
+exports.logAPIError = logAPIError;

package/dist/cjs/lib/api/dashboard/costing.js

@@ -0,0 +1,15 @@
+'use client';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCostingDashboardKpis = getCostingDashboardKpis;
+exports.assignQuotationAPI = assignQuotationAPI;
+const client_1 = __importDefault(require("../core/client.js"));
+async function getCostingDashboardKpis(filters, session) {
+    return client_1.default.post('api/dashboard/GetCostingDashboardKpis', filters, session);
+}
+async function assignQuotationAPI(bookingId, userId, session) {
+    return client_1.default.post('api/dashboard/AssignQuotation', { BookingID: bookingId, UserID: userId }, session);
+}

package/dist/cjs/lib/api/dashboard/management.js

@@ -0,0 +1,11 @@
+'use client';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManagementKpis = getManagementKpis;
+const client_1 = __importDefault(require("../core/client.js"));
+async function getManagementKpis(filters, session) {
+    return client_1.default.post('api/dashboard/GetSalesPipelineKpis', filters, session);
+}

package/dist/cjs/lib/api/dashboard/sales.js

@@ -0,0 +1,11 @@
+'use client';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSalesDashboardKpis = getSalesDashboardKpis;
+const client_1 = __importDefault(require("../core/client.js"));
+async function getSalesDashboardKpis(filters, session) {
+    return client_1.default.post('api/dashboard/GetSalesDashboardKpis', filters, session);
+}

package/dist/cjs/lib/api/draft/drafts.js

@@ -0,0 +1,279 @@
+'use client';
+"use strict";
+/**
+ * Draft Management API Client - Milestone Based
+ *
+ * Handles milestone-based saving and loading of estimation drafts.
+ * All draft data stored securely in SQL Server database (NOT localStorage).
+ * Matches Postman collection endpoints.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importDefault(require("../core/client.js"));
+/**
+ * Draft API - Matches Postman Collection
+ * Base URL: /api/draftsystem
+ */
+class DraftAPI {
+    /**
+     * Save a draft (milestone-based)
+     * POST /api/draftsystem/save
+     */
+    static async saveDraft(draftName, draftData, module, documentId, documentName, draftId, session, remark) {
+        try {
+            const requestBody = {
+                UserID: session?.user?.UserID || session?.user?.userID || 0,
+                CompanyID: session?.user?.CompanyID || session?.user?.companyID || 0,
+                Module: module,
+                DraftName: draftName || 'Untitled Draft',
+                DraftData: typeof draftData === 'string' ? draftData : JSON.stringify(draftData),
+                DocumentID: documentId || '',
+                DocumentName: documentName || '',
+                Remark: remark || '',
+                IsAutoSave: false,
+                RetentionDays: 30
+            };
+            // Include DraftID if updating existing draft
+            if (draftId) {
+                requestBody.DraftID = draftId;
+            }
+            const response = await client_1.default.post('/api/draftsystem/save', requestBody, session);
+            if (response.success && response.data?.data) {
+                return {
+                    success: true,
+                    data: response.data.data
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to save draft'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Load a specific draft
+     * GET /api/draftsystem/load/{draftId}
+     */
+    static async loadDraft(draftId, session) {
+        try {
+            const response = await client_1.default.get(`/api/draftsystem/load/${draftId}`, session);
+            if (response.success && response.data?.data) {
+                const backendData = response.data.data;
+                // Get date values (try both naming conventions)
+                const lastSavedRaw = backendData.LastSaved || backendData.lastSaved || backendData.UpdatedAt || backendData.updatedAt || backendData.CreatedAt || backendData.createdAt;
+                const expiresAtRaw = backendData.ExpiresAt || backendData.expiresAt;
+                const createdAtRaw = backendData.CreatedAt || backendData.createdAt;
+                // Parse dates with error handling
+                let lastSaved;
+                try {
+                    if (lastSavedRaw) {
+                        const date = new Date(lastSavedRaw);
+                        lastSaved = !isNaN(date.getTime()) ? date.toISOString() : new Date().toISOString();
+                    }
+                    else {
+                        lastSaved = new Date().toISOString();
+                    }
+                }
+                catch {
+                    lastSaved = new Date().toISOString();
+                }
+                let expiresAt;
+                try {
+                    if (expiresAtRaw) {
+                        const date = new Date(expiresAtRaw);
+                        expiresAt = !isNaN(date.getTime()) ? date.toISOString() : new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+                    }
+                    else {
+                        expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+                    }
+                }
+                catch {
+                    expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+                }
+                let createdAt;
+                try {
+                    if (createdAtRaw) {
+                        const date = new Date(createdAtRaw);
+                        createdAt = !isNaN(date.getTime()) ? date.toISOString() : new Date().toISOString();
+                    }
+                    else {
+                        createdAt = new Date().toISOString();
+                    }
+                }
+                catch {
+                    createdAt = new Date().toISOString();
+                }
+                // Transform PascalCase (C# backend) to camelCase (frontend)
+                const transformedData = {
+                    draftId: backendData.DraftID || backendData.draftId,
+                    userId: backendData.UserID || backendData.userId,
+                    companyId: backendData.CompanyID || backendData.companyId,
+                    module: backendData.Module || backendData.module,
+                    draftName: backendData.DraftName || backendData.draftName,
+                    draftData: (() => {
+                        const raw = backendData.DraftData || backendData.draftData;
+                        if (typeof raw === 'string') {
+                            try {
+                                return JSON.parse(raw);
+                            }
+                            catch {
+                                return raw;
+                            }
+                        }
+                        return raw;
+                    })(),
+                    isAutoSave: backendData.IsAutoSave || backendData.isAutoSave || false,
+                    lastSaved,
+                    expiresAt,
+                    createdAt
+                };
+                return {
+                    success: true,
+                    data: transformedData
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to load draft'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Draft API] Error loading draft:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * List all drafts for current user and module
+     * GET /api/draftsystem/list
+     */
+    static async listDrafts(module, session) {
+        try {
+            const response = await client_1.default.get(`/api/draftsystem/list?module=${encodeURIComponent(module)}`, session);
+            if (response.success && response.data?.data) {
+                // Transform PascalCase (C# backend) to camelCase (frontend)
+                const transformedData = response.data.data.map((item) => {
+                    // Get date values (try both naming conventions)
+                    const lastSavedRaw = item.LastSaved || item.lastSaved || item.UpdatedAt || item.updatedAt || item.CreatedAt || item.createdAt;
+                    const expiresAtRaw = item.ExpiresAt || item.expiresAt;
+                    // Parse date - try multiple formats
+                    let lastSaved;
+                    try {
+                        if (lastSavedRaw) {
+                            const date = new Date(lastSavedRaw);
+                            lastSaved = !isNaN(date.getTime()) ? date.toISOString() : new Date().toISOString();
+                        }
+                        else {
+                            lastSaved = new Date().toISOString();
+                        }
+                    }
+                    catch {
+                        lastSaved = new Date().toISOString();
+                    }
+                    let expiresAt;
+                    try {
+                        if (expiresAtRaw) {
+                            const date = new Date(expiresAtRaw);
+                            expiresAt = !isNaN(date.getTime()) ? date.toISOString() : new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+                        }
+                        else {
+                            expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+                        }
+                    }
+                    catch {
+                        expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+                    }
+                    return {
+                        draftId: item.DraftID || item.draftId,
+                        draftName: item.DraftName || item.draftName,
+                        module: item.Module || item.module,
+                        isAutoSave: item.IsAutoSave || item.isAutoSave || false,
+                        lastSaved,
+                        expiresAt,
+                        previewData: item.PreviewData || item.previewData || {}
+                    };
+                });
+                return {
+                    success: true,
+                    data: transformedData
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to list drafts'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Delete a draft
+     * DELETE /api/draftsystem/{draftId}
+     */
+    static async deleteDraft(draftId, session) {
+        try {
+            const response = await client_1.default.delete(`/api/draftsystem/${draftId}`, session);
+            if (response.success) {
+                return {
+                    success: true,
+                    data: { message: response.data?.message || 'Draft deleted successfully' }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to delete draft'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Draft API] Error deleting draft:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Rename a draft
+     * PUT /api/draftsystem/rename/{draftId}
+     */
+    static async renameDraft(draftId, newName, session) {
+        try {
+            const requestBody = {
+                DraftName: newName
+            };
+            const response = await client_1.default.put(`/api/draftsystem/rename/${draftId}`, requestBody, session);
+            if (response.success) {
+                return {
+                    success: true,
+                    data: { draftId, draftName: newName }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to rename draft'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Draft API] Error renaming draft:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+}
+exports.default = DraftAPI;

package/dist/cjs/lib/api/draft/index.js

@@ -0,0 +1,13 @@
+'use client';
+"use strict";
+/**
+ * Draft API Module
+ * Exports draft management functionality
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DraftAPI = void 0;
+var drafts_1 = require("./drafts.js");
+Object.defineProperty(exports, "DraftAPI", { enumerable: true, get: function () { return __importDefault(drafts_1).default; } });