indas-ui 0.0.1 → 0.1.0

package/dist/cjs/lib/api/activity/notifications/send.js

@@ -0,0 +1,267 @@
+'use client';
+"use strict";
+/**
+ * Notification Trigger Helpers
+ *
+ * Fire-and-forget functions that send notifications after business events.
+ * These NEVER block the calling flow — errors are silently swallowed.
+ *
+ * Usage:
+ *   import { notifyApprovalStatusChanged, notifyEnquiryConverted } from './send.js'
+ *   // After successful API response:
+ *   notifyApprovalStatusChanged({ ... }, session)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyApprovalStatusChanged = notifyApprovalStatusChanged;
+exports.notifyCostApproved = notifyCostApproved;
+exports.notifyEnquiryConverted = notifyEnquiryConverted;
+exports.notifyQuotationSaved = notifyQuotationSaved;
+exports.notifyQuotationMailSent = notifyQuotationMailSent;
+exports.notifyQuotationDeleted = notifyQuotationDeleted;
+exports.notifyEnquiryCreated = notifyEnquiryCreated;
+exports.notifyEnquiryAssigned = notifyEnquiryAssigned;
+exports.notifyEnquiryUpdated = notifyEnquiryUpdated;
+exports.notifyEnquiryDeleted = notifyEnquiryDeleted;
+exports.notifyUserCrud = notifyUserCrud;
+exports.notifyPasswordChanged = notifyPasswordChanged;
+exports.notifyMasterCrud = notifyMasterCrud;
+const notifications_1 = require("./notifications.js");
+/**
+ * Fire-and-forget: send a notification without blocking the caller.
+ * Uses the default APIClient base URL (api.indusanalytics.co.in).
+ */
+function fireNotification(request, session) {
+    notifications_1.NotificationsAPI.create(request, session).catch(() => {
+        // Silent — notification failure must never break business flows
+    });
+}
+const APPROVAL_ACTION_MAP = {
+    Approve: {
+        title: (bkNo, actor) => `Quotation ${bkNo} Approved`,
+        message: (bkNo, remarks) => `Quotation ${bkNo} has been internally approved${remarks ? `. Remarks: ${remarks}` : ''}`,
+        type: 'Approval',
+        category: 'Update',
+        priority: 'Normal'
+    },
+    Reject: {
+        title: (bkNo, actor) => `Quotation ${bkNo} Rejected`,
+        message: (bkNo, remarks) => `Quotation ${bkNo} has been rejected${remarks ? `. Reason: ${remarks}` : ''}`,
+        type: 'Warning',
+        category: 'Escalation',
+        priority: 'High'
+    },
+    Rework: {
+        title: (bkNo, actor) => `Quotation ${bkNo} — Rework Required`,
+        message: (bkNo, remarks) => `Quotation ${bkNo} requires rework${remarks ? `. Remarks: ${remarks}` : ''}`,
+        type: 'Warning',
+        category: 'Pending',
+        priority: 'High'
+    },
+    Pending: {
+        title: (bkNo, actor) => `Quotation ${bkNo} — Approval Needed`,
+        message: (bkNo, remarks) => `Quotation ${bkNo} has been sent for internal approval${remarks ? `. Remarks: ${remarks}` : ''}`,
+        type: 'Approval',
+        category: 'Pending',
+        priority: 'Urgent'
+    }
+};
+function notifyApprovalStatusChanged(params, session) {
+    const config = APPROVAL_ACTION_MAP[params.action];
+    if (!config)
+        return;
+    const request = {
+        title: config.title(params.bookingNo, params.actorUserName),
+        message: config.message(params.bookingNo, params.remarks),
+        type: config.type,
+        module: 'Quotation',
+        priority: config.priority,
+        category: config.category,
+        targetUserId: params.targetUserId,
+        targetUserName: params.targetUserName,
+        documentName: 'Quotation',
+        documentId: typeof params.bookingId === 'string' ? parseInt(params.bookingId) || undefined : params.bookingId,
+        documentNo: params.bookingNo,
+        actionUrl: `/costing/quote-panel`
+    };
+    fireNotification(request, session);
+}
+function notifyCostApproved(params, session) {
+    const clientPart = params.clientName ? ` for ${params.clientName}` : '';
+    const jobPart = params.jobName ? ` (${params.jobName})` : '';
+    fireNotification({
+        title: `Price Approval ${params.approvalNo} Saved`,
+        message: `Price approval ${params.approvalNo}${jobPart}${clientPart} has been approved by ${params.actorUserName}`,
+        type: 'Success',
+        module: 'Approval',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'Price Approval',
+        documentNo: params.approvalNo,
+        actionUrl: `/costing/price-approval`
+    }, session);
+}
+function notifyEnquiryConverted(params, session) {
+    const quotePart = params.bookingNo ? ` → Quotation ${params.bookingNo}` : '';
+    const jobPart = params.jobName ? ` (${params.jobName})` : '';
+    const request = {
+        title: `Enquiry ${params.enquiryNo} Converted${quotePart}`,
+        message: `Enquiry ${params.enquiryNo}${jobPart} has been converted to a quotation by ${params.actorUserName}`,
+        type: 'Success',
+        module: 'Enquiry',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        targetUserName: params.targetUserName,
+        documentName: 'Enquiry',
+        documentId: params.enquiryId,
+        documentNo: params.enquiryNo,
+        actionUrl: `/costing/estimation`
+    };
+    fireNotification(request, session);
+}
+function notifyQuotationSaved(params, session) {
+    const action = params.mode === 'clone' ? 'Cloned' : 'Created';
+    const clientPart = params.clientName ? ` for ${params.clientName}` : '';
+    fireNotification({
+        title: `Quotation ${params.bookingNo} ${action}`,
+        message: `Quotation ${params.bookingNo}${clientPart} has been ${action.toLowerCase()} by ${params.actorUserName}`,
+        type: 'Success',
+        module: 'Quotation',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'Quotation',
+        documentNo: params.bookingNo,
+        actionUrl: `/costing/quote-panel`
+    }, session);
+}
+function notifyQuotationMailSent(params, session) {
+    const clientPart = params.clientName ? ` to ${params.clientName}` : '';
+    fireNotification({
+        title: `Quotation ${params.bookingNo} Sent${clientPart}`,
+        message: `Quotation ${params.bookingNo} has been emailed${clientPart} by ${params.actorUserName}`,
+        type: 'Info',
+        module: 'Quotation',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'Quotation',
+        documentNo: params.bookingNo,
+        actionUrl: `/costing/quote-panel`
+    }, session);
+}
+function notifyQuotationDeleted(params, session) {
+    fireNotification({
+        title: `Quotation ${params.quoteNo} Deleted`,
+        message: `Quotation ${params.quoteNo}${params.jobName ? ` (${params.jobName})` : ''} was deleted by ${params.actorUserName}`,
+        type: 'Warning',
+        module: 'Quotation',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'Quotation',
+        documentNo: params.quoteNo,
+        actionUrl: `/costing/quote-panel`
+    }, session);
+}
+function notifyEnquiryCreated(params, session) {
+    const clientPart = params.clientName ? ` from ${params.clientName}` : '';
+    fireNotification({
+        title: `New Enquiry ${params.enquiryNo}`,
+        message: `Enquiry ${params.enquiryNo}${clientPart}${params.jobName ? ` — ${params.jobName}` : ''} created by ${params.actorUserName}`,
+        type: 'Info',
+        module: 'Enquiry',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'Enquiry',
+        documentNo: params.enquiryNo,
+        actionUrl: `/enquiry/sales`
+    }, session);
+}
+function notifyEnquiryAssigned(params, session) {
+    fireNotification({
+        title: `Enquiry${params.enquiryNo ? ` ${params.enquiryNo}` : ''} Assigned to You`,
+        message: `You have been assigned an enquiry by ${params.actorUserName}`,
+        type: 'Approval',
+        module: 'Enquiry',
+        priority: 'High',
+        category: 'Pending',
+        targetUserId: params.assignedToUserId,
+        targetUserName: params.assignedToUserName,
+        documentName: 'Enquiry',
+        documentId: params.enquiryId,
+        documentNo: params.enquiryNo,
+        actionUrl: `/enquiry/sales`
+    }, session);
+}
+function notifyEnquiryUpdated(params, session) {
+    const clientPart = params.clientName ? ` from ${params.clientName}` : '';
+    fireNotification({
+        title: `Enquiry ${params.enquiryNo} Updated`,
+        message: `Enquiry ${params.enquiryNo}${clientPart}${params.jobName ? ` — ${params.jobName}` : ''} updated by ${params.actorUserName}`,
+        type: 'Info',
+        module: 'Enquiry',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'Enquiry',
+        documentNo: params.enquiryNo,
+        actionUrl: `/enquiry/sales`
+    }, session);
+}
+function notifyEnquiryDeleted(params, session) {
+    fireNotification({
+        title: `Enquiry ${params.enquiryNo} Deleted`,
+        message: `Enquiry ${params.enquiryNo}${params.jobName ? ` (${params.jobName})` : ''} was deleted by ${params.actorUserName}`,
+        type: 'Warning',
+        module: 'Enquiry',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'Enquiry',
+        documentNo: params.enquiryNo,
+        actionUrl: `/enquiry/sales`
+    }, session);
+}
+function notifyUserCrud(params, session) {
+    fireNotification({
+        title: `User ${params.userName} ${params.action}`,
+        message: `User ${params.userName}${params.loginUserName ? ` (${params.loginUserName})` : ''} has been ${params.action.toLowerCase()} by ${params.actorUserName}`,
+        type: params.action === 'Deleted' ? 'Warning' : 'Info',
+        module: 'User',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: 'User',
+        actionUrl: `/master/user`
+    }, session);
+}
+function notifyPasswordChanged(params, session) {
+    fireNotification({
+        title: 'Password Changed',
+        message: `Password has been changed by ${params.actorUserName}`,
+        type: 'Warning',
+        module: 'User',
+        priority: 'High',
+        category: 'Escalation',
+        targetUserId: params.targetUserId,
+        documentName: 'User',
+        actionUrl: `/settings`
+    }, session);
+}
+function notifyMasterCrud(params, session) {
+    const codePart = params.code ? ` (${params.code})` : '';
+    fireNotification({
+        title: `${params.masterType} ${params.name} ${params.action}`,
+        message: `${params.masterType} ${params.name}${codePart} has been ${params.action.toLowerCase()} by ${params.actorUserName}`,
+        type: params.action === 'Deleted' ? 'Warning' : 'Info',
+        module: 'System',
+        priority: 'Normal',
+        category: 'Update',
+        targetUserId: params.targetUserId,
+        documentName: params.masterType,
+        actionUrl: `/master/${params.masterType.toLowerCase()}`
+    }, session);
+}

package/dist/cjs/lib/api/activity/notifications/types.js

@@ -0,0 +1,66 @@
+'use client';
+"use strict";
+/**
+ * Notification Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBackendNotification = fromBackendNotification;
+exports.toBackendNotificationRequest = toBackendNotificationRequest;
+/**
+ * Convert backend response (PascalCase DB columns) to frontend format
+ */
+function fromBackendNotification(backend) {
+    let metadata;
+    if (backend.Metadata) {
+        try {
+            metadata = JSON.parse(backend.Metadata);
+        }
+        catch {
+            metadata = undefined;
+        }
+    }
+    return {
+        notificationId: backend.NotificationID,
+        title: backend.Title,
+        message: backend.Message,
+        type: backend.Type,
+        module: backend.Module,
+        priority: backend.Priority,
+        category: backend.Category,
+        UserID: backend.UserID,
+        UserName: backend.UserName,
+        documentName: backend.DocumentName,
+        DocumentID: backend.DocumentID,
+        DocumentNo: backend.DocumentNo,
+        actionUrl: backend.ActionUrl,
+        isRead: backend.IsRead,
+        readAt: backend.ReadAt,
+        CreatedDate: backend.CreatedDate,
+        CreatedBy: backend.CreatedBy,
+        CompanyID: backend.CompanyID,
+        ProductionUnitID: backend.ProductionUnitID,
+        metadata,
+        // Legacy compat — UI code reads createdAt
+        createdAt: backend.CreatedDate
+    };
+}
+/**
+ * Convert frontend request to backend format (for POST /api/notifications)
+ */
+function toBackendNotificationRequest(request) {
+    return {
+        Title: request.title,
+        Message: request.message,
+        Type: request.type,
+        Module: request.module,
+        Priority: request.priority,
+        TargetUserID: request.targetUserId,
+        TargetUserName: request.targetUserName,
+        DocumentName: request.documentName,
+        DocumentID: request.documentId,
+        DocumentNo: request.documentNo,
+        ActionUrl: request.actionUrl,
+        Metadata: request.metadata,
+        Category: request.category
+    };
+}

package/dist/cjs/lib/api/activity/notify-and-log.js

@@ -0,0 +1,63 @@
+'use client';
+"use strict";
+/**
+ * notifyAndLog — the standard one-call helper for module actions.
+ *
+ * Every create / update / delete / approve / etc. action in any module should
+ * call this so the app consistently:
+ *   1. writes an audit log (via logAction), and
+ *   2. fires an in-app notification to the relevant user (via NotificationsAPI).
+ *
+ * Both are fire-and-forget — failures never block the business flow.
+ *
+ * Usage:
+ *   import { notifyAndLog } from './notify-and-log.js'
+ *
+ *   notifyAndLog({
+ *     module: AuditModule.QUOTATION,
+ *     action: AuditAction.APPROVE,
+ *     documentName: bookingNo,
+ *     documentId: bookingId,
+ *     // notification (optional — omit to only audit-log):
+ *     notify: {
+ *       targetUserId: requesterId,
+ *       title: 'Quotation approved',
+ *       message: `${actor} approved ${bookingNo}`,
+ *       type: 'Success',
+ *       module: 'Quotation',
+ *       actionUrl: '/costing/quote-panel',
+ *     },
+ *   }, session)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyAndLog = notifyAndLog;
+const send_1 = require("./audit/send.js");
+const notifications_1 = require("./notifications/notifications.js");
+function notifyAndLog(params, session) {
+    // 1. Audit log — always.
+    (0, send_1.logAction)({
+        module: params.module,
+        action: params.action,
+        documentName: params.documentName,
+        documentId: params.documentId,
+        comments: params.comments,
+        metadata: params.metadata,
+    }, session);
+    // 2. In-app notification — only when a target user is given, and never to self.
+    const n = params.notify;
+    const selfId = Number(session?.user?.UserID || session?.user?.userID || 0);
+    if (n && n.targetUserId && n.targetUserId !== selfId) {
+        notifications_1.NotificationsAPI.create({
+            title: n.title,
+            message: n.message,
+            type: n.type || 'Info',
+            module: n.module,
+            category: n.category,
+            priority: n.priority || 'Normal',
+            targetUserId: n.targetUserId,
+            documentNo: n.documentNo,
+            documentId: params.documentId,
+            actionUrl: n.actionUrl,
+        }, session).catch(() => { });
+    }
+}

package/dist/cjs/lib/api/activity/remarks/index.js

@@ -0,0 +1,6 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemarkIntelligenceAPI = void 0;
+var remarks_1 = require("./remarks.js");
+Object.defineProperty(exports, "RemarkIntelligenceAPI", { enumerable: true, get: function () { return remarks_1.RemarkIntelligenceAPI; } });

package/dist/cjs/lib/api/activity/remarks/remarks.js

@@ -0,0 +1,186 @@
+'use client';
+"use strict";
+/**
+ * Remark Intelligence API client (remarkData)
+ *
+ * One row per document (Module + DocumentID); full trail in Metadata JSON.
+ * See docs/superpowers/specs/2026-06-05-remark-intelligence-design.md
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemarkIntelligenceAPI = void 0;
+const client_1 = __importDefault(require("../../core/client.js"));
+// Backend sometimes returns multi-encoded JSON strings — unwrap up to 3 times.
+function parseList(data) {
+    let v = data;
+    for (let i = 0; i < 3 && typeof v === 'string'; i++) {
+        try {
+            v = JSON.parse(v);
+        }
+        catch {
+            return [];
+        }
+    }
+    return Array.isArray(v) ? v : [];
+}
+class RemarkIntelligenceAPI {
+    // Full trail for one document, or null if none yet.
+    static async getRemarkData(module, documentId, session) {
+        try {
+            const res = await client_1.default.get(`/api/remarks?module=${encodeURIComponent(module)}&documentID=${encodeURIComponent(String(documentId))}`, session);
+            const rows = parseList(res.data);
+            if (rows.length === 0)
+                return { success: true, data: null };
+            const row = rows[0];
+            let remarks = [];
+            let meta = row.Metadata;
+            for (let i = 0; i < 3 && typeof meta === 'string'; i++) {
+                try {
+                    meta = JSON.parse(meta);
+                }
+                catch {
+                    meta = null;
+                    break;
+                }
+            }
+            if (meta && Array.isArray(meta.remarks))
+                remarks = meta.remarks;
+            return { success: true, data: { ...row, remarks } };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load remarks' };
+        }
+    }
+    // All remark entries for a booking, consolidated across every module/stage
+    // (enquiry, quotation, revisions) — threaded by BookingNo. Returns a flat,
+    // chronologically-ordered trail with each entry tagged by its source module.
+    static async getRemarkDataByBooking(bookingNo, session, enquiry) {
+        try {
+            const params = new URLSearchParams({ bookingNo: String(bookingNo ?? '') });
+            if (enquiry?.enquiryNo)
+                params.set('enquiryNo', String(enquiry.enquiryNo));
+            if (enquiry?.enquiryID)
+                params.set('enquiryID', String(enquiry.enquiryID));
+            const res = await client_1.default.get(`/api/remarks/bybooking?${params.toString()}`, session);
+            const rows = parseList(res.data);
+            // Canonical stage name per source module (overrides per-entry stage so the
+            // trail reads consistently — "Estimation", "Sales Enquiry", etc.).
+            const stageForModule = (mod, docName) => {
+                const m = (mod || '').toLowerCase();
+                if (m === 'enquiry' || m.includes('/enquiry'))
+                    return 'Enquiry Remark';
+                if (m === 'quotation' || m.includes('quote-panel') || m.includes('/costing/estimation'))
+                    return 'Estimation Remark';
+                return docName || mod || '';
+            };
+            const all = [];
+            for (const row of rows) {
+                let meta = row.Metadata;
+                for (let i = 0; i < 3 && typeof meta === 'string'; i++) {
+                    try {
+                        meta = JSON.parse(meta);
+                    }
+                    catch {
+                        meta = null;
+                        break;
+                    }
+                }
+                if (meta && Array.isArray(meta.remarks)) {
+                    const stage = stageForModule(row.Module, row.DocumentName);
+                    for (const e of meta.remarks) {
+                        all.push({ ...e, stage });
+                    }
+                }
+            }
+            all.sort((a, b) => (a.at || '').localeCompare(b.at || ''));
+            return { success: true, data: all.map((e, i) => ({ ...e, seq: i + 1 })) };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load remarks' };
+        }
+    }
+    // Latest-only summaries for a list of documents, one call.
+    static async getRemarkDataBatch(module, documentIds, session) {
+        try {
+            const res = await client_1.default.post('/api/remarks/batch', { Module: module, DocumentIDs: documentIds.map(String) }, session);
+            const rows = parseList(res.data);
+            const map = {};
+            for (const r of rows)
+                map[String(r.DocumentID)] = r;
+            return { success: true, data: map };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load remarks' };
+        }
+    }
+    // Append a remark (or create the trail). Server computes seq/by/byName/at.
+    static async saveRemarkData(payload, session) {
+        try {
+            const res = await client_1.default.post('/api/remarks', { ...payload, DocumentID: String(payload.DocumentID) }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to save remark' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to save remark' };
+        }
+    }
+    // Save attachment rows to the universal store (JobBookingAttachments), keyed by Module + DocumentID.
+    static async saveAttachments(payload, session) {
+        try {
+            const res = await client_1.default.post('/api/remarks/attachments', { ...payload, DocumentID: String(payload.DocumentID) }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to save attachments' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to save attachments' };
+        }
+    }
+    // List saved attachment rows for a document.
+    static async getAttachments(module, documentId, session) {
+        try {
+            const res = await client_1.default.get(`/api/remarks/attachments?module=${encodeURIComponent(module)}&documentID=${encodeURIComponent(String(documentId))}`, session);
+            const rows = parseList(res.data);
+            return { success: true, data: rows };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load attachments' };
+        }
+    }
+    // Edit the last trail entry (server enforces: last entry, author, < 2h).
+    static async editRemarkData(module, documentId, seq, text, session) {
+        try {
+            const res = await client_1.default.post('/api/remarks/edit', { Module: module, DocumentID: String(documentId), seq, text }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to edit remark' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to edit remark' };
+        }
+    }
+    // Delete the last trail entry (same guards as edit).
+    static async deleteRemarkData(module, documentId, seq, session) {
+        try {
+            const res = await client_1.default.post('/api/remarks/delete', { Module: module, DocumentID: String(documentId), seq }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to delete remark' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to delete remark' };
+        }
+    }
+}
+exports.RemarkIntelligenceAPI = RemarkIntelligenceAPI;

package/dist/cjs/lib/api/activity/storage.js

@@ -0,0 +1,83 @@
+'use client';
+"use strict";
+/**
+ * Provider-agnostic file storage API client.
+ *
+ * Uploads go through the backend (/api/storage/upload), which reads the active
+ * provider from IntegrationConfig (code 'FileAttachments') and writes a
+ * JobBookingAttachments index row. Swapping providers is a backend config change;
+ * this client is unaffected.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFilesToStorage = uploadFilesToStorage;
+exports.storageFileUrl = storageFileUrl;
+function authHeaders(session) {
+    const companyUsername = session?.user?.companyUsername;
+    const companyPassword = session?.user?.companyPassword;
+    const authHeader = companyUsername && companyPassword
+        ? `Basic ${btoa(`${companyUsername}:${companyPassword}`)}`
+        : '';
+    return {
+        Authorization: authHeader,
+        CompanyID: String(session?.user?.CompanyID || session?.user?.companyID || ''),
+        UserID: String(session?.user?.UserID || session?.user?.userID || ''),
+        ProductionUnitID: String(session?.productionUnitId || session?.user?.ProductionUnitID || session?.user?.productionUnitID || ''),
+        FYear: session?.fYear || session?.user?.FYear || session?.user?.fYear || '',
+    };
+}
+// Upload files to the configured store and index them against a document.
+async function uploadFilesToStorage(files, params, session) {
+    if (!files || files.length === 0)
+        return { success: true, files: [], errors: [] };
+    try {
+        const form = new FormData();
+        form.append('module', params.module);
+        form.append('documentID', String(params.documentID));
+        form.append('documentName', params.documentName);
+        form.append('documentIDName', params.documentIDName);
+        form.append('indexRow', params.indexRow === false ? 'false' : 'true');
+        files.forEach((f) => form.append('file', f));
+        const baseURL = process.env.NEXT_PUBLIC_API_BASE_URL || '';
+        const res = await fetch(`${baseURL}/api/storage/upload`, {
+            method: 'POST',
+            headers: authHeaders(session),
+            body: form,
+        });
+        const text = await res.text();
+        if (!res.ok || text.toLowerCase().startsWith('fail') || text.toLowerCase().startsWith('"fail')) {
+            return { success: false, files: [], errors: [text || `Upload failed (${res.status})`] };
+        }
+        // Web API's Ok(jsonString) double-encodes: the body is a JSON string containing
+        // JSON. Parse repeatedly until we get an object (matches the remarks parseList).
+        let data = text;
+        for (let i = 0; i < 3 && typeof data === 'string'; i++) {
+            try {
+                data = JSON.parse(data);
+            }
+            catch {
+                data = null;
+                break;
+            }
+        }
+        if (!data || typeof data !== 'object') {
+            return { success: false, files: [], errors: ['Unexpected upload response'] };
+        }
+        return { success: !!data.success, files: data.files || [], errors: data.errors || [] };
+    }
+    catch (error) {
+        return { success: false, files: [], errors: [error instanceof Error ? error.message : 'Upload failed'] };
+    }
+}
+// Build the public URL for a stored file-attachment object key. The key is
+// provider-agnostic in the DB; the base lives in NEXT_PUBLIC_FILE_ATTACHMENT_BASE_URL so a
+// provider switch is an env change, not a data migration. Each path segment is encoded.
+function storageFileUrl(key) {
+    if (!key)
+        return '';
+    // Already a full URL (legacy rows that stored the URL) — use as-is.
+    if (/^https?:\/\//i.test(key))
+        return key;
+    const base = (process.env.NEXT_PUBLIC_FILE_ATTACHMENT_BASE_URL || '').replace(/\/+$/, '');
+    const encodedKey = key.split('/').map(encodeURIComponent).join('/');
+    return base ? `${base}/${encodedKey}` : encodedKey;
+}