514 lines
19 KiB
TypeScript
514 lines
19 KiB
TypeScript
import { Hono } from 'hono';
|
|
import { serveStatic } from 'hono/bun';
|
|
import fs from 'fs';
|
|
// @ts-ignore Bun project may not have dotenv types configured
|
|
import { config } from 'dotenv';
|
|
import { getCache, setCache, isRedisConnected } from './redis-cache';
|
|
|
|
config();
|
|
|
|
const app = new Hono();
|
|
|
|
// Minimal log helpers
|
|
const logLine = (path: string, line: string) => {
|
|
try {
|
|
fs.appendFileSync(path, `${new Date().toISOString()} ${line}\n`);
|
|
} catch (err) {
|
|
console.error('Failed to write log:', err);
|
|
}
|
|
};
|
|
|
|
// Version endpoint sourced from package.json
|
|
app.get('/version', (c) => {
|
|
try {
|
|
const pkgRaw = fs.readFileSync('./package.json', 'utf-8');
|
|
const pkg = JSON.parse(pkgRaw);
|
|
return c.json({ version: pkg.version || '0.0.0' });
|
|
} catch (err) {
|
|
logLine('logs/error.log', `version endpoint error: ${(err as Error)?.message || String(err)}`);
|
|
return c.json({ version: '0.0.0' }, 200);
|
|
}
|
|
});
|
|
|
|
// Jobs endpoint with Redis caching
|
|
app.get('/api/jobs', async (c) => {
|
|
const page = parseInt(c.req.query('page') || '1');
|
|
const perPage = parseInt(c.req.query('perPage') || '50');
|
|
const sort = c.req.query('sort') || '-Job_Number';
|
|
|
|
const cacheKey = `jobs:page:${page}:perPage:${perPage}:sort:${sort}`;
|
|
const ttl = 300; // 5 minutes cache
|
|
|
|
try {
|
|
// Try to get from cache first
|
|
if (isRedisConnected()) {
|
|
const cached = await getCache(cacheKey);
|
|
if (cached) {
|
|
logLine('logs/server.log', `Cache HIT for ${cacheKey}`);
|
|
return c.json(cached);
|
|
}
|
|
logLine('logs/server.log', `Cache MISS for ${cacheKey}`);
|
|
}
|
|
|
|
// Fetch from PocketBase
|
|
const pbUrl = `https://pocketbase.ccllc.pro/api/collections/pbc_1407612689/records?page=${page}&perPage=${perPage}&sort=${sort}`;
|
|
const authHeader = c.req.header('Authorization') || '';
|
|
|
|
const response = await fetch(pbUrl, {
|
|
headers: authHeader ? { Authorization: authHeader } : {}
|
|
});
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`PocketBase returned ${response.status}`);
|
|
}
|
|
|
|
const data = await response.json();
|
|
|
|
// Cache the result
|
|
if (isRedisConnected()) {
|
|
await setCache(cacheKey, data, ttl);
|
|
logLine('logs/server.log', `Cached ${cacheKey} for ${ttl}s`);
|
|
}
|
|
|
|
return c.json(data);
|
|
|
|
} catch (err) {
|
|
logLine('logs/error.log', `jobs endpoint error: ${(err as Error)?.message || String(err)}`);
|
|
return c.json({ error: 'Failed to fetch jobs' }, 500);
|
|
}
|
|
});
|
|
|
|
// Fast endpoint: returns all jobs in a single cached request
|
|
app.get('/api/jobs-all', async (c) => {
|
|
const cacheKey = 'jobs:all';
|
|
const ttl = 1800; // 30 minutes cache
|
|
try {
|
|
// Try cache first for instant response
|
|
if (isRedisConnected()) {
|
|
const cached = await getCache(cacheKey);
|
|
if (cached) {
|
|
logLine('logs/server.log', `Cache HIT for ${cacheKey} (${cached.items?.length || 0} jobs)`);
|
|
// Return cached data immediately
|
|
setImmediate(async () => {
|
|
try {
|
|
await refreshJobsCache(cacheKey, ttl, c.req.header('Authorization') || '');
|
|
} catch (err) {}
|
|
});
|
|
// Return all cached jobs in a single response
|
|
return c.json({ ...cached, partial: false });
|
|
} else {
|
|
// No cache: return empty array instantly, trigger background fetch
|
|
setImmediate(async () => {
|
|
try {
|
|
const result = await fetchAllJobsFromPocketBase(c.req.header('Authorization') || '');
|
|
if (isRedisConnected()) {
|
|
await setCache(cacheKey, result, ttl);
|
|
logLine('logs/server.log', `Cached ${cacheKey} with ${result.items.length} jobs for ${ttl}s`);
|
|
}
|
|
} catch (err) {
|
|
logLine('logs/error.log', `jobs-all background fetch error: ${(err as Error)?.message || String(err)}`);
|
|
}
|
|
});
|
|
return c.json({ items: [], partial: true });
|
|
}
|
|
}
|
|
// Redis not connected: fallback to direct fetch (blocking)
|
|
const result = await fetchAllJobsFromPocketBase(c.req.header('Authorization') || '');
|
|
return c.json(result);
|
|
} catch (err) {
|
|
logLine('logs/error.log', `jobs-all endpoint error: ${(err as Error)?.message || String(err)}`);
|
|
return c.json({ error: 'Failed to fetch jobs' }, 500);
|
|
}
|
|
});
|
|
|
|
// Helper function to fetch all jobs from PocketBase
|
|
async function fetchAllJobsFromPocketBase(authHeader: string): Promise<any> {
|
|
const allItems: any[] = [];
|
|
let page = 1;
|
|
const perPage = 500;
|
|
|
|
while (true) {
|
|
const pbUrl = `https://pocketbase.ccllc.pro/api/collections/pbc_1407612689/records?page=${page}&perPage=${perPage}&sort=-Job_Number`;
|
|
const response = await fetch(pbUrl, {
|
|
headers: authHeader ? { Authorization: authHeader } : {}
|
|
});
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`PocketBase returned ${response.status}`);
|
|
}
|
|
|
|
const data = await response.json();
|
|
const items = data.items || [];
|
|
|
|
if (items.length === 0) break;
|
|
allItems.push(...items);
|
|
|
|
if (allItems.length >= (data.totalItems || 0)) break;
|
|
page++;
|
|
}
|
|
|
|
return {
|
|
page: 1,
|
|
perPage: allItems.length,
|
|
totalItems: allItems.length,
|
|
totalPages: 1,
|
|
items: allItems
|
|
};
|
|
}
|
|
|
|
// Helper function to refresh jobs cache in background
|
|
async function refreshJobsCache(cacheKey: string, ttl: number, authHeader: string): Promise<void> {
|
|
try {
|
|
const result = await fetchAllJobsFromPocketBase(authHeader);
|
|
await setCache(cacheKey, result, ttl);
|
|
logLine('logs/server.log', `Background refresh: cached ${cacheKey} with ${result.items.length} jobs`);
|
|
} catch (err) {
|
|
logLine('logs/error.log', `Background refresh error: ${(err as Error)?.message || String(err)}`);
|
|
}
|
|
}
|
|
|
|
|
|
// --- Microsoft Graph helpers ---
|
|
const getGraphToken = (c?: any) => {
|
|
const headerToken = c?.req?.header ? c.req.header('x-graph-token') : '';
|
|
const envToken = process.env.GRAPH_TOKEN || process.env.MS_GRAPH_TOKEN || '';
|
|
const token = headerToken || envToken;
|
|
console.log('[getGraphToken] Header token:', headerToken ? headerToken.substring(0, 20) + '...' : 'NONE');
|
|
console.log('[getGraphToken] Env token:', envToken ? 'SET' : 'NOT SET');
|
|
console.log('[getGraphToken] Using:', token ? token.substring(0, 20) + '...' : 'NONE');
|
|
return token;
|
|
};
|
|
|
|
const b64Url = (input: string) =>
|
|
Buffer.from(input).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
|
|
|
|
type DriveItem = {
|
|
id: string;
|
|
name: string;
|
|
webUrl?: string;
|
|
size?: number;
|
|
lastModifiedDateTime?: string;
|
|
file?: { mimeType?: string };
|
|
folder?: { childCount?: number };
|
|
parentReference?: { path?: string; driveId?: string };
|
|
};
|
|
|
|
const fetchJson = async (url: string, token: string) => {
|
|
const res = await fetch(url, {
|
|
headers: {
|
|
Authorization: `Bearer ${token}`,
|
|
Accept: 'application/json',
|
|
},
|
|
});
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
const err: any = new Error(`Graph ${res.status}: ${text}`);
|
|
err.status = res.status;
|
|
throw err;
|
|
}
|
|
return res.json();
|
|
};
|
|
|
|
const resolveShareLink = async (link: string, token: string) => {
|
|
// Decode the link in case it comes pre-encoded from the database
|
|
const decodedLink = decodeURIComponent(link);
|
|
console.log('[resolveShareLink] Decoded link:', decodedLink);
|
|
|
|
// Check if this is a short sharing link (/:f:/ or /:b:/) or a direct document library URL
|
|
if (decodedLink.includes('/:f:/') || decodedLink.includes('/:b:/')) {
|
|
// Short sharing link - use shares API
|
|
const encoded = `u!${b64Url(decodedLink)}`;
|
|
console.log('[resolveShareLink] Using shares API, encoded:', encoded);
|
|
const data = await fetchJson(`https://graph.microsoft.com/v1.0/shares/${encoded}/driveItem`, token);
|
|
return { driveId: data.parentReference?.driveId as string, itemId: data.id as string };
|
|
} else {
|
|
// Direct document library URL - parse it and use drive API
|
|
// Example: https://czflex.sharepoint.com/sites/Team/Shared Documents/Forms/AllItems.aspx?RootFolder=/sites/Team/Shared Documents/General/...
|
|
const url = new URL(decodedLink);
|
|
const pathMatch = url.hostname.match(/^([^.]+)\.sharepoint\.com$/);
|
|
if (!pathMatch) throw new Error('Invalid SharePoint URL');
|
|
|
|
const hostname = pathMatch[1]; // e.g., 'czflex'
|
|
const sitePath = url.pathname.split('/Shared')[0]; // e.g., /sites/Team
|
|
const rootFolderParam = url.searchParams.get('RootFolder');
|
|
if (!rootFolderParam) throw new Error('RootFolder parameter missing');
|
|
|
|
// Extract the folder path relative to the document library
|
|
// RootFolder format: /sites/Team/Shared Documents/General/Operations [Server]/...
|
|
// We need: General/Operations [Server]/...
|
|
const folderPath = rootFolderParam.split('/Shared Documents/')[1];
|
|
if (!folderPath) throw new Error('Could not parse folder path');
|
|
|
|
console.log('[resolveShareLink] Hostname:', hostname);
|
|
console.log('[resolveShareLink] Site path:', sitePath);
|
|
console.log('[resolveShareLink] Folder path:', folderPath);
|
|
|
|
// Get the site ID first using hostname:sitePath format
|
|
const siteData = await fetchJson(`https://graph.microsoft.com/v1.0/sites/${hostname}.sharepoint.com:${sitePath}`, token);
|
|
const siteId = siteData.id;
|
|
|
|
// Get the default document library drive
|
|
const driveData = await fetchJson(`https://graph.microsoft.com/v1.0/sites/${siteId}/drive`, token);
|
|
const driveId = driveData.id;
|
|
|
|
// Get the folder item by path
|
|
const itemData = await fetchJson(
|
|
`https://graph.microsoft.com/v1.0/drives/${driveId}/root:/${folderPath}`,
|
|
token
|
|
);
|
|
|
|
console.log('[resolveShareLink] Resolved to driveId:', driveId, 'itemId:', itemData.id);
|
|
return { driveId, itemId: itemData.id };
|
|
}
|
|
};
|
|
|
|
const listChildrenRecursive = async (
|
|
driveId: string,
|
|
itemId: string,
|
|
depth = 0,
|
|
maxDepth = 5,
|
|
token: string,
|
|
): Promise<DriveItem[]> => {
|
|
const out: DriveItem[] = [];
|
|
const data = await fetchJson(`https://graph.microsoft.com/v1.0/drives/${driveId}/items/${itemId}/children`, token);
|
|
for (const child of data.value || []) {
|
|
out.push(child as DriveItem);
|
|
if (child.folder && depth < maxDepth) {
|
|
const nested = await listChildrenRecursive(driveId, child.id, depth + 1, maxDepth, token);
|
|
out.push(...nested);
|
|
}
|
|
}
|
|
return out;
|
|
};
|
|
|
|
const searchWithinFolder = async (driveId: string, itemId: string, query: string, token: string): Promise<DriveItem[]> => {
|
|
const data = await fetchJson(
|
|
`https://graph.microsoft.com/v1.0/drives/${driveId}/items/${itemId}/search(q='${encodeURIComponent(query)}')`,
|
|
token,
|
|
);
|
|
return (data.value || []) as DriveItem[];
|
|
};
|
|
|
|
const filterByCategory = (items: DriveItem[], category?: string, pdfOnly: boolean = true) => {
|
|
// First filter: show PDF files and Word documents (which will be converted to PDF)
|
|
let filtered = items;
|
|
if (pdfOnly) {
|
|
filtered = items.filter((i) => {
|
|
if (i.folder) return false;
|
|
const name = i.name.toLowerCase();
|
|
const mimeType = i.file?.mimeType?.toLowerCase() || '';
|
|
// Include PDFs, Word documents, and images
|
|
return name.endsWith('.pdf') || mimeType.includes('pdf') ||
|
|
name.endsWith('.doc') || name.endsWith('.docx') || mimeType.includes('word') ||
|
|
name.endsWith('.jpg') || name.endsWith('.jpeg') || name.endsWith('.png') ||
|
|
name.endsWith('.gif') || name.endsWith('.bmp') || name.endsWith('.tiff') ||
|
|
name.endsWith('.webp') || mimeType.includes('image');
|
|
});
|
|
}
|
|
|
|
// Second filter: category filtering (if specified)
|
|
if (!category) return filtered;
|
|
const nameHas = (name: string, words: string[]) => words.some((w) => name.includes(w));
|
|
const lc = (s: string) => (s || '').toLowerCase();
|
|
const contractWords = ['contract', 'estimate', 'proposal', 'bid', 'award', 'agreement', 'sow'];
|
|
const planWords = ['plan', 'drawing', 'dwg', 'pdf', 'sheet', 'layout'];
|
|
return filtered.filter((i) => {
|
|
const n = lc(i.name);
|
|
if (category === 'contracts') return nameHas(n, contractWords);
|
|
if (category === 'plans') return nameHas(n, planWords);
|
|
return true;
|
|
});
|
|
};
|
|
|
|
// List/search job files via Graph using a shared folder link
|
|
app.get('/api/job-files', async (c) => {
|
|
try {
|
|
console.log('[job-files] Request received');
|
|
const token = getGraphToken(c);
|
|
if (!token) {
|
|
console.log('[job-files] No token found');
|
|
return c.json({ error: 'GRAPH_TOKEN missing' }, 500);
|
|
}
|
|
console.log('[job-files] Token found:', token.substring(0, 20) + '...');
|
|
const link = c.req.query('link');
|
|
const q = c.req.query('q') || '';
|
|
const category = c.req.query('category') || '';
|
|
if (!link) return c.json({ error: 'link required' }, 400);
|
|
console.log('[job-files] Link:', link);
|
|
|
|
const { driveId, itemId } = await resolveShareLink(link, token);
|
|
|
|
let items: DriveItem[] = [];
|
|
if (q) {
|
|
items = await searchWithinFolder(driveId, itemId, q, token);
|
|
} else {
|
|
// Walk subfolders up to depth 5
|
|
items = await listChildrenRecursive(driveId, itemId, 0, 5, token);
|
|
}
|
|
|
|
// Filter to show only PDFs by default (can be disabled with pdfOnly=false query param)
|
|
const pdfOnly = c.req.query('pdfOnly') !== 'false';
|
|
const filtered = filterByCategory(items, category, pdfOnly);
|
|
console.log(`[job-files] Found ${items.length} total items, ${filtered.length} after filtering`);
|
|
|
|
const mapped = filtered.map((i) => ({
|
|
id: i.id,
|
|
name: i.name,
|
|
url: i.webUrl,
|
|
driveId: i.parentReference?.driveId || driveId,
|
|
size: i.size,
|
|
modified: i.lastModifiedDateTime,
|
|
contentType: i.file?.mimeType,
|
|
isFolder: Boolean(i.folder),
|
|
path: i.parentReference?.path || '',
|
|
}));
|
|
|
|
return c.json({ items: mapped, total: mapped.length, source: q ? 'search' : 'walk', driveId });
|
|
} catch (err) {
|
|
const message = (err as Error)?.message || String(err);
|
|
const status = (err as any)?.status || 500;
|
|
console.error('[job-files] ERROR:', message);
|
|
logLine('logs/error.log', `/api/job-files error: ${message}`);
|
|
return c.json({ error: message }, status);
|
|
}
|
|
});
|
|
|
|
// Stream file content via Graph to avoid CSP issues for inline preview
|
|
app.get('/api/job-file-content', async (c) => {
|
|
try {
|
|
const token = getGraphToken(c);
|
|
if (!token) return c.json({ error: 'GRAPH_TOKEN missing' }, 500);
|
|
const driveId = c.req.query('driveId');
|
|
const itemId = c.req.query('itemId');
|
|
if (!driveId || !itemId) return c.json({ error: 'driveId and itemId required' }, 400);
|
|
|
|
const res = await fetch(`https://graph.microsoft.com/v1.0/drives/${driveId}/items/${itemId}/content`, {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
logLine('logs/error.log', `/api/job-file-content failed: ${res.status} - ${text}`);
|
|
return c.json({ error: `Graph ${res.status}: ${text}` }, 502);
|
|
}
|
|
const headers: Record<string, string> = {};
|
|
const ct = res.headers.get('content-type');
|
|
const cd = res.headers.get('content-disposition');
|
|
if (ct) headers['Content-Type'] = ct;
|
|
if (cd) headers['Content-Disposition'] = cd;
|
|
return new Response(res.body, { status: 200, headers });
|
|
} catch (err) {
|
|
const message = (err as Error)?.message || String(err);
|
|
const status = (err as any)?.status || 500;
|
|
logLine('logs/error.log', `/api/job-file-content error: ${message}`);
|
|
return c.json({ error: message }, status);
|
|
}
|
|
});
|
|
|
|
// Convert Word documents to PDF for display
|
|
app.get('/api/job-file-pdf', async (c) => {
|
|
try {
|
|
const token = getGraphToken(c);
|
|
if (!token) return c.json({ error: 'GRAPH_TOKEN missing' }, 500);
|
|
const driveId = c.req.query('driveId');
|
|
const itemId = c.req.query('itemId');
|
|
if (!driveId || !itemId) return c.json({ error: 'driveId and itemId required' }, 400);
|
|
|
|
// Use Graph API to convert to PDF format
|
|
const res = await fetch(`https://graph.microsoft.com/v1.0/drives/${driveId}/items/${itemId}/content?format=pdf`, {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
logLine('logs/error.log', `/api/job-file-pdf conversion failed: ${res.status} - ${text}`);
|
|
return c.json({ error: `PDF conversion failed: ${res.status}` }, 502);
|
|
}
|
|
const headers: Record<string, string> = {
|
|
'Content-Type': 'application/pdf',
|
|
};
|
|
const cd = res.headers.get('content-disposition');
|
|
if (cd) {
|
|
// Replace .docx/.doc extension with .pdf in filename
|
|
headers['Content-Disposition'] = cd.replace(/\.(docx?)/gi, '.pdf');
|
|
}
|
|
logLine('logs/server.log', `Successfully converted document to PDF: driveId=${driveId}, itemId=${itemId}`);
|
|
return new Response(res.body, { status: 200, headers });
|
|
} catch (err) {
|
|
const message = (err as Error)?.message || String(err);
|
|
const status = (err as any)?.status || 500;
|
|
logLine('logs/error.log', `/api/job-file-pdf error: ${message}`);
|
|
return c.json({ error: message }, status);
|
|
}
|
|
});
|
|
|
|
// Mutation logging endpoint
|
|
app.post('/log-change', async (c) => {
|
|
try {
|
|
const body = await c.req.json();
|
|
const { action = 'unknown', user = 'unknown', target = '', detail = '' } = body || {};
|
|
const payload = JSON.stringify({ action, user, target, detail });
|
|
logLine('logs/changes.log', payload);
|
|
return c.json({ status: 'ok' });
|
|
} catch (err) {
|
|
logLine('logs/error.log', `log-change error: ${(err as Error)?.message || String(err)}`);
|
|
return c.text('Bad Request', 400);
|
|
}
|
|
});
|
|
|
|
// Serve static files from the frontend directory (must come after API routes)
|
|
// Add cache headers for static assets
|
|
app.use('/assets/*', async (c, next) => {
|
|
await next();
|
|
// Cache assets for 1 year
|
|
c.header('Cache-Control', 'public, max-age=31536000, immutable');
|
|
});
|
|
app.use('/*', serveStatic({ root: './frontend' }));
|
|
|
|
// Error handler
|
|
app.onError((err, c) => {
|
|
logLine('logs/error.log', `Unhandled error: ${err?.message || err}`);
|
|
return c.text('Internal Server Error', 500);
|
|
});
|
|
|
|
// Default to 3005 for test instance; can be overridden by Environment=PORT
|
|
const PORT = Number(process.env.PORT || 3005);
|
|
|
|
logLine('logs/server.log', `Starting frontend server (Redis version) on port ${PORT}`);
|
|
|
|
// Warm up cache on startup
|
|
(async () => {
|
|
try {
|
|
if (isRedisConnected()) {
|
|
logLine('logs/server.log', 'Warming up jobs cache...');
|
|
const result = await fetchAllJobsFromPocketBase('');
|
|
await setCache('jobs:all', result, 1800);
|
|
logLine('logs/server.log', `✓ Cache warmed with ${result.items.length} jobs`);
|
|
}
|
|
} catch (err) {
|
|
logLine('logs/error.log', `Cache warmup failed: ${(err as Error)?.message || String(err)}`);
|
|
}
|
|
})();
|
|
|
|
// Background refresh every 5 minutes to keep cache hot
|
|
setInterval(async () => {
|
|
try {
|
|
if (isRedisConnected()) {
|
|
await refreshJobsCache('jobs:all', 1800, '');
|
|
}
|
|
} catch (err) {
|
|
logLine('logs/error.log', `Periodic refresh error: ${(err as Error)?.message || String(err)}`);
|
|
}
|
|
}, 5 * 60 * 1000); // Every 5 minutes
|
|
|
|
// Graceful shutdown logging
|
|
const shutdown = (signal: string) => {
|
|
logLine('logs/server.log', `Shutting down due to ${signal}`);
|
|
process.exit(0);
|
|
};
|
|
process.on('SIGINT', () => shutdown('SIGINT'));
|
|
process.on('SIGTERM', () => shutdown('SIGTERM'));
|
|
|
|
export default {
|
|
port: PORT,
|
|
fetch: app.fetch,
|
|
};
|