545 lines
16 KiB
TypeScript
545 lines
16 KiB
TypeScript
import { NextResponse } from "next/server";
|
|
import type { NextRequest } from "next/server";
|
|
import { createHash } from "crypto";
|
|
import { prisma } from "@/lib/prisma";
|
|
import { requireSession } from "@/lib/auth/requireSession";
|
|
import { logLine } from "@/lib/logger";
|
|
import { elapsedMs, formatServerTiming, nowMs, PERF_LOGS_ENABLED } from "@/lib/perf/serverTiming";
|
|
|
|
let reportsColdStart = true;
|
|
|
|
function getColdStartInfo() {
|
|
const coldStart = reportsColdStart;
|
|
reportsColdStart = false;
|
|
return { coldStart, uptimeMs: Math.round(process.uptime() * 1000) };
|
|
}
|
|
|
|
const RANGE_MS: Record<string, number> = {
|
|
"24h": 24 * 60 * 60 * 1000,
|
|
"7d": 7 * 24 * 60 * 60 * 1000,
|
|
"30d": 30 * 24 * 60 * 60 * 1000,
|
|
};
|
|
|
|
function parseDate(input?: string | null) {
|
|
if (!input) return null;
|
|
const n = Number(input);
|
|
if (!Number.isNaN(n)) return new Date(n);
|
|
const d = new Date(input);
|
|
return Number.isNaN(d.getTime()) ? null : d;
|
|
}
|
|
|
|
function pickRange(req: NextRequest) {
|
|
const url = new URL(req.url);
|
|
const range = url.searchParams.get("range") ?? "24h";
|
|
const now = new Date();
|
|
|
|
if (range === "custom") {
|
|
const start = parseDate(url.searchParams.get("start")) ?? new Date(now.getTime() - RANGE_MS["24h"]);
|
|
const end = parseDate(url.searchParams.get("end")) ?? now;
|
|
return { start, end };
|
|
}
|
|
|
|
const ms = RANGE_MS[range] ?? RANGE_MS["24h"];
|
|
return { start: new Date(now.getTime() - ms), end: now };
|
|
}
|
|
|
|
function safeNum(v: unknown) {
|
|
return typeof v === "number" && Number.isFinite(v) ? v : null;
|
|
}
|
|
|
|
function isProductionSnapshot(trackingEnabled: unknown, productionStarted: unknown) {
|
|
return trackingEnabled === true && productionStarted === true;
|
|
}
|
|
|
|
function toMs(value?: Date | null) {
|
|
return value ? value.getTime() : 0;
|
|
}
|
|
|
|
export async function GET(req: NextRequest) {
|
|
const perfEnabled = PERF_LOGS_ENABLED;
|
|
const totalStart = nowMs();
|
|
const timings: Record<string, number> = {};
|
|
const { coldStart, uptimeMs } = getColdStartInfo();
|
|
|
|
const authStart = nowMs();
|
|
const session = await requireSession();
|
|
if (perfEnabled) timings.auth = elapsedMs(authStart);
|
|
if (!session) return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
|
|
|
|
const preQueryStart = nowMs();
|
|
const url = new URL(req.url);
|
|
const range = url.searchParams.get("range") ?? "24h";
|
|
const machineId = url.searchParams.get("machineId") ?? undefined;
|
|
const { start, end } = pickRange(req);
|
|
const workOrderId = url.searchParams.get("workOrderId") ?? undefined;
|
|
const sku = url.searchParams.get("sku") ?? undefined;
|
|
const baseWhere = {
|
|
orgId: session.orgId,
|
|
...(machineId ? { machineId } : {}),
|
|
...(workOrderId ? { workOrderId } : {}),
|
|
...(sku ? { sku } : {}),
|
|
};
|
|
|
|
if (perfEnabled) timings.preQuery = elapsedMs(preQueryStart);
|
|
|
|
const versionStart = nowMs();
|
|
const [kpiMax, cycleMax, eventMax] = await Promise.all([
|
|
prisma.machineKpiSnapshot.aggregate({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
_max: { tsServer: true },
|
|
}),
|
|
prisma.machineCycle.aggregate({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
_max: { tsServer: true },
|
|
}),
|
|
prisma.machineEvent.aggregate({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
_max: { tsServer: true },
|
|
}),
|
|
]);
|
|
if (perfEnabled) timings.version = elapsedMs(versionStart);
|
|
|
|
const lastModifiedMs = Math.max(
|
|
toMs(kpiMax._max.tsServer),
|
|
toMs(cycleMax._max.tsServer),
|
|
toMs(eventMax._max.tsServer)
|
|
);
|
|
|
|
const versionParts = [
|
|
session.orgId,
|
|
range,
|
|
machineId ?? "",
|
|
workOrderId ?? "",
|
|
sku ?? "",
|
|
toMs(kpiMax._max.tsServer),
|
|
toMs(cycleMax._max.tsServer),
|
|
toMs(eventMax._max.tsServer),
|
|
];
|
|
const etag = `W/"${createHash("sha1").update(versionParts.join("|")).digest("hex")}"`;
|
|
const responseHeaders = new Headers({
|
|
"Cache-Control": "private, no-cache, max-age=0, must-revalidate",
|
|
ETag: etag,
|
|
"Last-Modified": new Date(lastModifiedMs || 0).toUTCString(),
|
|
Vary: "Cookie",
|
|
});
|
|
|
|
const ifNoneMatch = req.headers.get("if-none-match");
|
|
if (ifNoneMatch && ifNoneMatch === etag) {
|
|
return new NextResponse(null, { status: 304, headers: responseHeaders });
|
|
}
|
|
|
|
const kpiStart = nowMs();
|
|
const kpiRows = await prisma.machineKpiSnapshot.findMany({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
orderBy: { ts: "asc" },
|
|
select: {
|
|
ts: true,
|
|
oee: true,
|
|
availability: true,
|
|
performance: true,
|
|
quality: true,
|
|
good: true,
|
|
scrap: true,
|
|
target: true,
|
|
trackingEnabled: true,
|
|
productionStarted: true,
|
|
machineId: true,
|
|
},
|
|
});
|
|
if (perfEnabled) timings.kpiRows = elapsedMs(kpiStart);
|
|
|
|
let oeeSum = 0;
|
|
let oeeCount = 0;
|
|
let availSum = 0;
|
|
let availCount = 0;
|
|
let perfSum = 0;
|
|
let perfCount = 0;
|
|
let qualSum = 0;
|
|
let qualCount = 0;
|
|
|
|
// OEE-family summaries are production-only to avoid mixing downtime/off windows.
|
|
for (const k of kpiRows) {
|
|
if (!isProductionSnapshot(k.trackingEnabled, k.productionStarted)) continue;
|
|
if (safeNum(k.oee) != null) {
|
|
oeeSum += Number(k.oee);
|
|
oeeCount += 1;
|
|
}
|
|
if (safeNum(k.availability) != null) {
|
|
availSum += Number(k.availability);
|
|
availCount += 1;
|
|
}
|
|
if (safeNum(k.performance) != null) {
|
|
perfSum += Number(k.performance);
|
|
perfCount += 1;
|
|
}
|
|
if (safeNum(k.quality) != null) {
|
|
qualSum += Number(k.quality);
|
|
qualCount += 1;
|
|
}
|
|
}
|
|
|
|
const cyclesStart = nowMs();
|
|
const cycles = await prisma.machineCycle.findMany({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
select: { goodDelta: true, scrapDelta: true },
|
|
});
|
|
if (perfEnabled) timings.cycles = elapsedMs(cyclesStart);
|
|
|
|
let goodTotal = 0;
|
|
let scrapTotal = 0;
|
|
|
|
for (const c of cycles) {
|
|
if (safeNum(c.goodDelta) != null) goodTotal += Number(c.goodDelta);
|
|
if (safeNum(c.scrapDelta) != null) scrapTotal += Number(c.scrapDelta);
|
|
}
|
|
|
|
const kpiAggStart = nowMs();
|
|
const kpiAgg = await prisma.machineKpiSnapshot.groupBy({
|
|
by: ["machineId"],
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
_max: { good: true, scrap: true, target: true },
|
|
_min: { good: true, scrap: true },
|
|
_count: { _all: true },
|
|
});
|
|
if (perfEnabled) timings.kpiAgg = elapsedMs(kpiAggStart);
|
|
|
|
let targetTotal = 0;
|
|
if (goodTotal === 0 && scrapTotal === 0) {
|
|
let goodFallback = 0;
|
|
let scrapFallback = 0;
|
|
|
|
for (const row of kpiAgg) {
|
|
const count = row._count._all ?? 0;
|
|
const maxGood = safeNum(row._max.good);
|
|
const minGood = safeNum(row._min.good);
|
|
const maxScrap = safeNum(row._max.scrap);
|
|
const minScrap = safeNum(row._min.scrap);
|
|
|
|
if (count > 1 && maxGood != null && minGood != null) {
|
|
goodFallback += Math.max(0, maxGood - minGood);
|
|
} else if (maxGood != null) {
|
|
goodFallback += maxGood;
|
|
}
|
|
|
|
if (count > 1 && maxScrap != null && minScrap != null) {
|
|
scrapFallback += Math.max(0, maxScrap - minScrap);
|
|
} else if (maxScrap != null) {
|
|
scrapFallback += maxScrap;
|
|
}
|
|
}
|
|
|
|
goodTotal = goodFallback;
|
|
scrapTotal = scrapFallback;
|
|
}
|
|
|
|
for (const row of kpiAgg) {
|
|
const maxTarget = safeNum(row._max.target);
|
|
if (maxTarget != null) targetTotal += maxTarget;
|
|
}
|
|
|
|
const eventsStart = nowMs();
|
|
const events = await prisma.machineEvent.findMany({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
select: { eventType: true, data: true },
|
|
});
|
|
if (perfEnabled) timings.events = elapsedMs(eventsStart);
|
|
|
|
let macrostopSec = 0;
|
|
let microstopSec = 0;
|
|
let slowCycleCount = 0;
|
|
let qualitySpikeCount = 0;
|
|
let performanceDegradationCount = 0;
|
|
let oeeDropCount = 0;
|
|
|
|
for (const e of events) {
|
|
const type = String(e.eventType ?? "").toLowerCase();
|
|
let blob: unknown = e.data;
|
|
|
|
if (typeof blob === "string") {
|
|
try {
|
|
blob = JSON.parse(blob);
|
|
} catch {
|
|
blob = null;
|
|
}
|
|
}
|
|
|
|
const blobRecord = typeof blob === "object" && blob !== null ? (blob as Record<string, unknown>) : null;
|
|
const innerCandidate = blobRecord?.data ?? blobRecord ?? {};
|
|
const inner =
|
|
typeof innerCandidate === "object" && innerCandidate !== null
|
|
? (innerCandidate as Record<string, unknown>)
|
|
: {};
|
|
const stopSec =
|
|
(typeof inner?.stoppage_duration_seconds === "number" && inner.stoppage_duration_seconds) ||
|
|
(typeof inner?.stop_duration_seconds === "number" && inner.stop_duration_seconds) ||
|
|
0;
|
|
|
|
if (type === "macrostop") macrostopSec += Number(stopSec) || 0;
|
|
else if (type === "microstop") microstopSec += Number(stopSec) || 0;
|
|
else if (type === "slow-cycle") slowCycleCount += 1;
|
|
else if (type === "quality-spike") qualitySpikeCount += 1;
|
|
else if (type === "performance-degradation") performanceDegradationCount += 1;
|
|
else if (type === "oee-drop") oeeDropCount += 1;
|
|
}
|
|
|
|
type TrendPoint = { t: string; v: number | null };
|
|
|
|
const trend: {
|
|
oee: TrendPoint[];
|
|
availability: TrendPoint[];
|
|
performance: TrendPoint[];
|
|
quality: TrendPoint[];
|
|
scrapRate: TrendPoint[];
|
|
} = {
|
|
oee: [],
|
|
availability: [],
|
|
performance: [],
|
|
quality: [],
|
|
scrapRate: [],
|
|
};
|
|
|
|
type TsBucket = {
|
|
oeeSum: number; oeeCount: number;
|
|
availSum: number; availCount: number;
|
|
perfSum: number; perfCount: number;
|
|
qualSum: number; qualCount: number;
|
|
goodSum: number; scrapSum: number;
|
|
anyProduction: boolean;
|
|
};
|
|
const tsBuckets = new Map<string, TsBucket>();
|
|
|
|
for (const k of kpiRows) {
|
|
const t = k.ts.toISOString();
|
|
let b = tsBuckets.get(t);
|
|
if (!b) {
|
|
b = {
|
|
oeeSum: 0, oeeCount: 0,
|
|
availSum: 0, availCount: 0,
|
|
perfSum: 0, perfCount: 0,
|
|
qualSum: 0, qualCount: 0,
|
|
goodSum: 0, scrapSum: 0,
|
|
anyProduction: false,
|
|
};
|
|
tsBuckets.set(t, b);
|
|
}
|
|
|
|
const isProd = isProductionSnapshot(k.trackingEnabled, k.productionStarted);
|
|
if (isProd) {
|
|
b.anyProduction = true;
|
|
const oee = safeNum(k.oee);
|
|
if (oee != null) { b.oeeSum += Number(oee); b.oeeCount += 1; }
|
|
const avail = safeNum(k.availability);
|
|
if (avail != null) { b.availSum += Number(avail); b.availCount += 1; }
|
|
const perf = safeNum(k.performance);
|
|
if (perf != null) { b.perfSum += Number(perf); b.perfCount += 1; }
|
|
const qual = safeNum(k.quality);
|
|
if (qual != null) { b.qualSum += Number(qual); b.qualCount += 1; }
|
|
}
|
|
|
|
const good = safeNum(k.good);
|
|
const scrap = safeNum(k.scrap);
|
|
if (good != null) b.goodSum += Number(good);
|
|
if (scrap != null) b.scrapSum += Number(scrap);
|
|
}
|
|
|
|
// Iterate sorted ts. kpiRows already orderBy ts asc, but Map insertion
|
|
// order matches that, so spreading keys preserves order.
|
|
for (const [t, b] of tsBuckets) {
|
|
if (!b.anyProduction) {
|
|
// No machine producing at this ts -> gap, same as before.
|
|
trend.oee.push({ t, v: null });
|
|
trend.availability.push({ t, v: null });
|
|
trend.performance.push({ t, v: null });
|
|
trend.quality.push({ t, v: null });
|
|
} else {
|
|
trend.oee.push({ t, v: b.oeeCount ? b.oeeSum / b.oeeCount : null });
|
|
trend.availability.push({ t, v: b.availCount ? b.availSum / b.availCount : null });
|
|
trend.performance.push({ t, v: b.perfCount ? b.perfSum / b.perfCount : null });
|
|
trend.quality.push({ t, v: b.qualCount ? b.qualSum / b.qualCount : null });
|
|
}
|
|
const total = b.goodSum + b.scrapSum;
|
|
if (total > 0) {
|
|
trend.scrapRate.push({ t, v: (b.scrapSum / total) * 100 });
|
|
}
|
|
}
|
|
const cycleRowsStart = nowMs();
|
|
const cycleRows = await prisma.machineCycle.findMany({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
select: { actualCycleTime: true },
|
|
});
|
|
if (perfEnabled) timings.cycleRows = elapsedMs(cycleRowsStart);
|
|
|
|
const values = cycleRows
|
|
.map((c) => Number(c.actualCycleTime))
|
|
.filter((v) => Number.isFinite(v) && v > 0)
|
|
.sort((a, b) => a - b);
|
|
|
|
let cycleTimeBins: {
|
|
label: string;
|
|
count: number;
|
|
rangeStart?: number;
|
|
rangeEnd?: number;
|
|
overflow?: "low" | "high";
|
|
minValue?: number;
|
|
maxValue?: number;
|
|
}[] = [];
|
|
|
|
if (values.length) {
|
|
const pct = (p: number) => {
|
|
const idx = Math.max(0, Math.min(values.length - 1, Math.floor(p * (values.length - 1))));
|
|
return values[idx];
|
|
};
|
|
|
|
const p5 = pct(0.05);
|
|
const p95 = pct(0.95);
|
|
|
|
const inRange = values.filter((v) => v >= p5 && v <= p95);
|
|
const low = values.filter((v) => v < p5);
|
|
const high = values.filter((v) => v > p95);
|
|
|
|
const binCount = 10;
|
|
const span = Math.max(0.1, p95 - p5);
|
|
const step = span / binCount;
|
|
|
|
const counts = new Array(binCount).fill(0);
|
|
for (const v of inRange) {
|
|
const idx = Math.min(binCount - 1, Math.floor((v - p5) / step));
|
|
counts[idx] += 1;
|
|
}
|
|
const decimals = step < 0.1 ? 2 : step < 1 ? 1 : 0;
|
|
|
|
cycleTimeBins = counts.map((count, i) => {
|
|
const a = p5 + step * i;
|
|
const b = p5 + step * (i + 1);
|
|
return {
|
|
label: `${a.toFixed(decimals)}-${b.toFixed(decimals)}s`,
|
|
count,
|
|
rangeStart: a,
|
|
rangeEnd: b,
|
|
};
|
|
});
|
|
|
|
|
|
if (low.length) {
|
|
cycleTimeBins.unshift({
|
|
label: `< ${p5.toFixed(1)}s`,
|
|
count: low.length,
|
|
rangeEnd: p5,
|
|
overflow: "low",
|
|
minValue: low[0],
|
|
maxValue: low[low.length - 1],
|
|
});
|
|
}
|
|
|
|
if (high.length) {
|
|
cycleTimeBins.push({
|
|
label: `> ${p95.toFixed(1)}s`,
|
|
count: high.length,
|
|
rangeStart: p95,
|
|
overflow: "high",
|
|
minValue: high[0],
|
|
maxValue: high[high.length - 1],
|
|
});
|
|
}
|
|
}
|
|
const scrapRate =
|
|
goodTotal + scrapTotal > 0 ? (scrapTotal / (goodTotal + scrapTotal)) * 100 : null;
|
|
|
|
|
|
|
|
// top scrap SKU / work order (from cycles)
|
|
const scrapBySku = new Map<string, number>();
|
|
const scrapByWo = new Map<string, number>();
|
|
|
|
const scrapRowsStart = nowMs();
|
|
const scrapRows = await prisma.machineCycle.findMany({
|
|
where: { ...baseWhere, ts: { gte: start, lte: end } },
|
|
select: { sku: true, workOrderId: true, scrapDelta: true },
|
|
});
|
|
if (perfEnabled) timings.scrapRows = elapsedMs(scrapRowsStart);
|
|
|
|
const postQueryStart = nowMs();
|
|
|
|
for (const row of scrapRows) {
|
|
const scrap = safeNum(row.scrapDelta);
|
|
if (scrap == null || scrap <= 0) continue;
|
|
if (row.sku) scrapBySku.set(row.sku, (scrapBySku.get(row.sku) ?? 0) + scrap);
|
|
if (row.workOrderId) scrapByWo.set(row.workOrderId, (scrapByWo.get(row.workOrderId) ?? 0) + scrap);
|
|
}
|
|
|
|
const topScrapSku = [...scrapBySku.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
|
|
const topScrapWorkOrder = [...scrapByWo.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
|
|
|
|
const oeeAvg = oeeCount ? oeeSum / oeeCount : null;
|
|
const availabilityAvg = availCount ? availSum / availCount : null;
|
|
const performanceAvg = perfCount ? perfSum / perfCount : null;
|
|
const qualityAvg = qualCount ? qualSum / qualCount : null;
|
|
|
|
// insights
|
|
const insights: string[] = [];
|
|
if (scrapRate != null && scrapRate > 5) insights.push(`Scrap rate is ${scrapRate.toFixed(1)}% (above 5%).`);
|
|
if (performanceAvg != null && performanceAvg < 85) insights.push("Performance below 85%.");
|
|
if (availabilityAvg != null && availabilityAvg < 85) insights.push("Availability below 85%.");
|
|
if (oeeAvg != null && oeeAvg < 85) insights.push("OEE below 85%.");
|
|
if (macrostopSec > 1800) insights.push("Macrostop time exceeds 30 minutes in this range.");
|
|
|
|
|
|
|
|
const payload = {
|
|
ok: true,
|
|
summary: {
|
|
oeeAvg,
|
|
availabilityAvg,
|
|
performanceAvg,
|
|
qualityAvg,
|
|
goodTotal,
|
|
scrapTotal,
|
|
targetTotal,
|
|
scrapRate,
|
|
topScrapSku,
|
|
topScrapWorkOrder,
|
|
},
|
|
|
|
downtime: {
|
|
macrostopSec,
|
|
microstopSec,
|
|
slowCycleCount,
|
|
qualitySpikeCount,
|
|
performanceDegradationCount,
|
|
oeeDropCount,
|
|
},
|
|
trend,
|
|
insights,
|
|
distribution: {
|
|
cycleTime: cycleTimeBins,
|
|
},
|
|
};
|
|
|
|
if (perfEnabled) {
|
|
timings.postQuery = elapsedMs(postQueryStart);
|
|
timings.total = elapsedMs(totalStart);
|
|
responseHeaders.set("Server-Timing", formatServerTiming(timings));
|
|
const payloadBytes = Buffer.byteLength(JSON.stringify(payload));
|
|
logLine("perf.reports.api", {
|
|
orgId: session.orgId,
|
|
coldStart,
|
|
uptimeMs,
|
|
range,
|
|
machineId,
|
|
workOrderId,
|
|
sku,
|
|
timings,
|
|
rowCounts: {
|
|
kpiRows: kpiRows.length,
|
|
cycles: cycles.length,
|
|
events: events.length,
|
|
cycleRows: cycleRows.length,
|
|
scrapRows: scrapRows.length,
|
|
},
|
|
payloadBytes,
|
|
});
|
|
}
|
|
|
|
return NextResponse.json(payload, { headers: responseHeaders });
|
|
}
|