@debugkit/dashboard 0.6.1 → 0.8.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client/assets/_authed-CNObwuZh.js +7 -0
- package/dist/client/assets/_authed-CuP-He8G.js +1 -0
- package/dist/client/assets/{charts-XyOWJI9T.js → charts-CUvev8lV.js} +7 -7
- package/dist/client/assets/copy-button-ORgLIh59.js +1 -0
- package/dist/client/assets/customers-DTMEprFQ.js +1 -0
- package/dist/client/assets/endpoints-lMSO2CdM.js +1 -0
- package/dist/client/assets/events._eventId-bWag-i8J.js +3 -0
- package/dist/client/assets/index-BNpacHyi.js +10 -0
- package/dist/client/assets/invite._token-CxXek2SP.js +1 -0
- package/dist/client/assets/issues._fingerprint-BQr85TVY.js +1 -0
- package/dist/client/assets/login-Dlk3GyyC.js +1 -0
- package/dist/client/assets/sessions._sessionId-3wNImMqM.js +1 -0
- package/dist/client/assets/settings-CzbEYB7k.js +1 -0
- package/dist/client/assets/src-Dq5mIUf0.js +3 -0
- package/dist/client/assets/styles-DPsgRH7g.css +2 -0
- package/dist/client/assets/team-Bud2-07A.js +1 -0
- package/dist/client/assets/timeline-BSDhQPpY.js +1 -0
- package/dist/client/assets/ui-CEv2y56s.js +1 -0
- package/dist/server/assets/{_authed-CrjuC0O3.js → _authed-DkkRwdZl.js} +19 -5
- package/dist/server/assets/{_authed-C-sIPXSO.js → _authed-DsB8kjZB.js} +318 -126
- package/dist/server/assets/_tanstack-start-manifest_v-D1_ErrJK.js +97 -0
- package/dist/server/assets/copy-button-D3RddzTw.js +52 -0
- package/dist/server/assets/customers-CvSLt_xV.js +163 -0
- package/dist/server/assets/{demo-BsMMDk_F.js → demo-BRTkdmQJ.js} +25 -4
- package/dist/server/assets/{dynamodb-Zkk1-mgz.js → dynamodb-B0V3ZO20.js} +45 -17
- package/dist/server/assets/endpoints-mPQXpH8C.js +371 -0
- package/dist/server/assets/{queries-BJxX3Kjp.js → errors-C2KEDL7l.js} +842 -62
- package/dist/server/assets/events._eventId-pkQBQ9sL.js +765 -0
- package/dist/server/assets/{firestore-C52q_vwM.js → firestore-Jd-LeWZI.js} +15 -6
- package/dist/server/assets/fns-B3PHbFwV.js +1295 -0
- package/dist/server/assets/{fns-DwGaMi8S.js → fns-Di0vMpkQ.js} +25 -3
- package/dist/server/assets/{invite._token-xnpnkdRv.js → invite._token-LwWF5YxP.js} +3 -3
- package/dist/server/assets/{issues._fingerprint-e7ubdJf0.js → issues._fingerprint-DAA0QCuA.js} +89 -11
- package/dist/server/assets/{login-EopnOJXA.js → login-DqjCU4DJ.js} +3 -3
- package/dist/server/assets/{memory-BssaqdZm.js → memory-aqsrtEUn.js} +377 -26
- package/dist/server/assets/router-C0Dauj2C.js +510 -0
- package/dist/server/assets/sessions._sessionId-D7JPV0M4.js +264 -0
- package/dist/server/assets/{settings-CaJN69N6.js → settings-Drjd64d7.js} +165 -5
- package/dist/server/assets/{src-D83GYTrp.js → src-C4fNgijW.js} +1 -1
- package/dist/server/assets/{team-B1UcM1jA.js → team-D7iXYnSE.js} +3 -3
- package/dist/server/assets/timeline-MDRNDhiA.js +132 -0
- package/dist/server/assets/{ui-BJokJdYa.js → ui-B_XHlLUQ.js} +53 -13
- package/dist/server/server.js +37 -21
- package/package.json +4 -4
- package/dist/client/assets/_authed-BN39b-7H.js +0 -1
- package/dist/client/assets/_authed-CspAf0jN.js +0 -7
- package/dist/client/assets/index-Bfb2UOzB.js +0 -10
- package/dist/client/assets/invite._token-B4HN51-h.js +0 -1
- package/dist/client/assets/issues._fingerprint-BV1QrETY.js +0 -1
- package/dist/client/assets/login-COlvJ5Je.js +0 -1
- package/dist/client/assets/preload-helper-Dscj_TcA.js +0 -3
- package/dist/client/assets/settings-Dl4EWeWC.js +0 -1
- package/dist/client/assets/styles-DztngwT9.css +0 -2
- package/dist/client/assets/team-7Zekz_Er.js +0 -1
- package/dist/client/assets/ui-C0HGOza2.js +0 -1
- package/dist/server/assets/_tanstack-start-manifest_v-CqaE4wze.js +0 -61
- package/dist/server/assets/fns-mbUIXXep.js +0 -529
- package/dist/server/assets/router-G99085_Q.js +0 -315
|
@@ -0,0 +1,1295 @@
|
|
|
1
|
+
import { n as TSS_SERVER_FUNCTION, t as createServerFn } from "../server.js";
|
|
2
|
+
import { A as seenHosts, D as teamAction, E as hashInviteToken, F as writeRetention, I as writeSettings, L as getLocalWriteStore, M as testAlert, N as validRetention, O as readSettings, P as writeIssueStatus, R as getStore, T as isRequestCategory, _ as hashPassword, a as buildSummary, b as startSession, c as resolveRange, d as canManage, f as checkCredentials, g as forgetMember, h as envOwnerEmails, i as buildIssueDetail, j as settingsWriter, k as restampStep, l as DEMO_USER, m as endSession, n as isMissingIndex, o as endpointTimings, p as demoLoginEnabled, s as retentionFor, t as isIndexError, v as readSession, x as tooManyAttempts, y as recordFailure, z as config } from "./errors-C2KEDL7l.js";
|
|
3
|
+
import { _ as validHostNames, h as nameUrlsIn, m as hostNameFor } from "./memory-aqsrtEUn.js";
|
|
4
|
+
import { n as TEAM_ROLES } from "./src-C4fNgijW.js";
|
|
5
|
+
import { redirect } from "@tanstack/react-router";
|
|
6
|
+
// ../../node_modules/.pnpm/@tanstack+start-server-core@1.169.45/node_modules/@tanstack/start-server-core/dist/esm/createServerRpc.js
|
|
7
|
+
var createServerRpc = (serverFnMeta, splitImportFn) => {
|
|
8
|
+
const url = "/_serverFn/" + serverFnMeta.id;
|
|
9
|
+
return Object.assign(splitImportFn, {
|
|
10
|
+
url,
|
|
11
|
+
serverFnMeta,
|
|
12
|
+
[TSS_SERVER_FUNCTION]: true
|
|
13
|
+
});
|
|
14
|
+
};
|
|
15
|
+
/** A fatal error: labelled a crash, or uncaught and critical, which is how the SDK sends a fatal one. */
|
|
16
|
+
function isCrash(e) {
|
|
17
|
+
return e.event.type === "error" && (e.labels?.category === "crash" || !e.event.handled && e.event.severity === "critical");
|
|
18
|
+
}
|
|
19
|
+
/** crashed, errored (an uncaught error) or clean, as on the session page. */
|
|
20
|
+
function sessionOutcome(events) {
|
|
21
|
+
if (events.some(isCrash)) return "crashed";
|
|
22
|
+
return events.some((e) => e.event.type === "error" && !e.event.handled) ? "errored" : "clean";
|
|
23
|
+
}
|
|
24
|
+
/** The prop that says why a flow failed, in the order apps tend to name it. */
|
|
25
|
+
var REASON_KEYS = [
|
|
26
|
+
"reason",
|
|
27
|
+
"error",
|
|
28
|
+
"errorKind",
|
|
29
|
+
"code",
|
|
30
|
+
"message"
|
|
31
|
+
];
|
|
32
|
+
var OUTCOME_WORD = {
|
|
33
|
+
success: "succeeded",
|
|
34
|
+
failure: "failed",
|
|
35
|
+
abandoned: "abandoned"
|
|
36
|
+
};
|
|
37
|
+
/** "auth.login: failed, wrongOtp". */
|
|
38
|
+
function describeEvent(name, outcome, props, step) {
|
|
39
|
+
const reason = REASON_KEYS.map((k) => props?.[k]).find((v) => typeof v === "string" || typeof v === "number");
|
|
40
|
+
const parts = [outcome ? OUTCOME_WORD[outcome] ?? outcome : void 0, reason !== void 0 ? String(reason) : void 0].filter(Boolean);
|
|
41
|
+
return `${name}${step ? ` · ${step}` : ""}${parts.length ? `: ${parts.join(", ")}` : ""}`;
|
|
42
|
+
}
|
|
43
|
+
/**
|
|
44
|
+
* Each breadcrumb once: errors in the same session carry overlapping trails. Given the events
|
|
45
|
+
* oldest first, each breadcrumb's source is the earliest error that carried it, the one it led to.
|
|
46
|
+
*
|
|
47
|
+
* When the SDK merges a repeat it moves the breadcrumb's time to the latest repeat, so a later
|
|
48
|
+
* trail can hold the same breadcrumb with a newer time and a higher count. Nothing else was
|
|
49
|
+
* recorded between it and the breadcrumb before it, so an identical one in that window is the
|
|
50
|
+
* same run: keep the copy with the highest count.
|
|
51
|
+
*/
|
|
52
|
+
function uniqueCrumbs(events) {
|
|
53
|
+
const out = [];
|
|
54
|
+
const exact = /* @__PURE__ */ new Map();
|
|
55
|
+
const count = (b) => Number(b.data?.repeated ?? 1);
|
|
56
|
+
for (const e of events) {
|
|
57
|
+
if (e.event.type !== "error") continue;
|
|
58
|
+
const source = e.fingerprint ? {
|
|
59
|
+
eventId: e.event.id,
|
|
60
|
+
fingerprint: e.fingerprint
|
|
61
|
+
} : void 0;
|
|
62
|
+
let after = -Infinity;
|
|
63
|
+
for (const b of e.event.breadcrumbs ?? []) {
|
|
64
|
+
const t = Date.parse(b.ts);
|
|
65
|
+
const same = (c) => c.crumb.category === b.category && c.crumb.message === b.message && c.crumb.level === b.level;
|
|
66
|
+
const had = exact.get(`${b.ts}|${b.category}|${b.message}`) ?? (count(b) > 1 ? out.find((c) => same(c) && Date.parse(c.crumb.ts) > after && Date.parse(c.crumb.ts) <= t) : void 0);
|
|
67
|
+
if (!had) {
|
|
68
|
+
const c = {
|
|
69
|
+
crumb: b,
|
|
70
|
+
source
|
|
71
|
+
};
|
|
72
|
+
out.push(c);
|
|
73
|
+
exact.set(`${b.ts}|${b.category}|${b.message}`, c);
|
|
74
|
+
} else if (count(b) > count(had.crumb)) {
|
|
75
|
+
had.crumb = b;
|
|
76
|
+
exact.set(`${b.ts}|${b.category}|${b.message}`, had);
|
|
77
|
+
}
|
|
78
|
+
after = t;
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
return out;
|
|
82
|
+
}
|
|
83
|
+
/** How far apart a custom event and its own breadcrumb, or an api.failed event and its call, can be. */
|
|
84
|
+
var SAME_MS = 2e3;
|
|
85
|
+
/** The SDK writes each custom event as an "event" breadcrumb too: the breadcrumb that is this event, if any. */
|
|
86
|
+
function ownCrumb(name, ts, crumbs, taken) {
|
|
87
|
+
const t = Date.parse(ts);
|
|
88
|
+
return crumbs.find((c) => !taken.has(c) && c.crumb.category === "event" && c.crumb.message === name && Math.abs(Date.parse(c.crumb.ts) - t) <= SAME_MS);
|
|
89
|
+
}
|
|
90
|
+
/** The app's api.failed event says the same as the failed call's breadcrumb next to it. */
|
|
91
|
+
function repeatsCrumb(e, crumbs) {
|
|
92
|
+
if (e.event.type !== "event" || e.event.name !== "api.failed") return false;
|
|
93
|
+
const path = e.event.props?.path;
|
|
94
|
+
const t = Date.parse(e.event.ts);
|
|
95
|
+
return crumbs.some((c) => c.api?.failed && c.api.path === path && Math.abs(Date.parse(c.ts) - t) <= SAME_MS);
|
|
96
|
+
}
|
|
97
|
+
async function buildSessionDetail(store, app, sessionId) {
|
|
98
|
+
const [events, settings] = await Promise.all([store.listSessionEvents(app, sessionId, { limit: 501 }), store.getSettings(app).catch(() => null)]);
|
|
99
|
+
if (!events.length) return null;
|
|
100
|
+
const truncated = events.length > 500;
|
|
101
|
+
const page = events.slice(-500);
|
|
102
|
+
const hosts = settings?.hosts ?? [];
|
|
103
|
+
const carried = withoutSdkTwinsCarried(uniqueCrumbs(page));
|
|
104
|
+
const taken = /* @__PURE__ */ new Set();
|
|
105
|
+
const own = /* @__PURE__ */ new Map();
|
|
106
|
+
for (const e of page) {
|
|
107
|
+
if (e.event.type !== "event") continue;
|
|
108
|
+
const c = ownCrumb(e.event.name, e.event.ts, carried, taken);
|
|
109
|
+
if (c) {
|
|
110
|
+
taken.add(c);
|
|
111
|
+
own.set(e, c);
|
|
112
|
+
}
|
|
113
|
+
}
|
|
114
|
+
const kept = carried.filter((c) => !taken.has(c)).map((c) => ({
|
|
115
|
+
ts: c.crumb.ts,
|
|
116
|
+
item: readCrumb(c.crumb, hosts),
|
|
117
|
+
source: c.source
|
|
118
|
+
}));
|
|
119
|
+
const crumbs = kept.map((c) => c.item);
|
|
120
|
+
const rows = kept.map((c) => ({
|
|
121
|
+
kind: "crumb",
|
|
122
|
+
...c
|
|
123
|
+
}));
|
|
124
|
+
let errors = 0;
|
|
125
|
+
let handled = 0;
|
|
126
|
+
for (const e of page) {
|
|
127
|
+
const ev = e.event;
|
|
128
|
+
if (ev.type === "error") {
|
|
129
|
+
const crash = isCrash(e);
|
|
130
|
+
errors++;
|
|
131
|
+
if (ev.handled) handled++;
|
|
132
|
+
rows.push({
|
|
133
|
+
kind: "error",
|
|
134
|
+
ts: ev.ts,
|
|
135
|
+
eventId: ev.id,
|
|
136
|
+
fingerprint: e.fingerprint,
|
|
137
|
+
title: nameUrlsIn(`${ev.error.name}: ${ev.error.message}`, hosts),
|
|
138
|
+
handled: ev.handled,
|
|
139
|
+
crash
|
|
140
|
+
});
|
|
141
|
+
} else if (ev.type === "event" && !repeatsCrumb(e, crumbs)) rows.push({
|
|
142
|
+
kind: "event",
|
|
143
|
+
ts: ev.ts,
|
|
144
|
+
eventId: ev.id,
|
|
145
|
+
name: ev.name,
|
|
146
|
+
outcome: ev.outcome,
|
|
147
|
+
detail: describeEvent(ev.name, ev.outcome, ev.props, ev.step),
|
|
148
|
+
failed: ev.outcome === "failure",
|
|
149
|
+
source: own.get(e)?.source
|
|
150
|
+
});
|
|
151
|
+
}
|
|
152
|
+
const order = {
|
|
153
|
+
crumb: 0,
|
|
154
|
+
event: 1,
|
|
155
|
+
error: 2
|
|
156
|
+
};
|
|
157
|
+
const sorted = byTime(rows.sort((a, b) => order[a.kind] - order[b.kind]));
|
|
158
|
+
const last = page[page.length - 1];
|
|
159
|
+
return {
|
|
160
|
+
app,
|
|
161
|
+
sessionId,
|
|
162
|
+
user: {
|
|
163
|
+
id: last.user?.id,
|
|
164
|
+
anonymousId: last.user?.anonymousId
|
|
165
|
+
},
|
|
166
|
+
context: last.context,
|
|
167
|
+
start: sorted[0]?.ts ?? page[0].event.ts,
|
|
168
|
+
end: last.event.ts,
|
|
169
|
+
outcome: sessionOutcome(page),
|
|
170
|
+
counts: {
|
|
171
|
+
errors,
|
|
172
|
+
handled,
|
|
173
|
+
events: sorted.filter((r) => r.kind === "event").length
|
|
174
|
+
},
|
|
175
|
+
rows: sorted,
|
|
176
|
+
truncated,
|
|
177
|
+
read: page.length
|
|
178
|
+
};
|
|
179
|
+
}
|
|
180
|
+
/** How far after an error its "what they did next" reaches. */
|
|
181
|
+
var AFTER_MS = 3e5;
|
|
182
|
+
/**
|
|
183
|
+
* What the customer did after an error, from the trails of the session's later errors: the steps
|
|
184
|
+
* within five minutes of it, at most `limit`. Empty when nothing later was stored or the session
|
|
185
|
+
* can't be read (Firestore without its index).
|
|
186
|
+
*/
|
|
187
|
+
async function stepsAfter(store, app, sessionId, ts, hosts = [], limit = 30) {
|
|
188
|
+
const events = await store.listSessionEvents(app, sessionId, { limit: 500 }).catch((e) => {
|
|
189
|
+
if (isIndexError(String(e?.message))) return [];
|
|
190
|
+
throw e;
|
|
191
|
+
});
|
|
192
|
+
const t = Date.parse(ts);
|
|
193
|
+
return byTime(withoutSdkTwinsCarried(uniqueCrumbs(events)).filter((c) => {
|
|
194
|
+
const d = Date.parse(c.crumb.ts) - t;
|
|
195
|
+
return d > 0 && d <= AFTER_MS;
|
|
196
|
+
}).map((c) => c.crumb)).slice(0, limit).map((b) => readCrumb(b, hosts));
|
|
197
|
+
}
|
|
198
|
+
/** withoutSdkTwins over carried breadcrumbs, keeping each one's source. */
|
|
199
|
+
function withoutSdkTwinsCarried(carried) {
|
|
200
|
+
const keep = new Set(withoutSdkTwins(carried.map((c) => c.crumb)));
|
|
201
|
+
return carried.filter((c) => keep.has(c.crumb));
|
|
202
|
+
}
|
|
203
|
+
// src/server/exchange.ts
|
|
204
|
+
function sideOf(s) {
|
|
205
|
+
return {
|
|
206
|
+
headers: s.headers && Object.keys(s.headers).length ? s.headers : void 0,
|
|
207
|
+
body: s.body,
|
|
208
|
+
bodySize: s.bodySize,
|
|
209
|
+
truncated: s.truncated || void 0
|
|
210
|
+
};
|
|
211
|
+
}
|
|
212
|
+
/** Whether the SDK captured anything beyond the call itself: only with network.bodies on. */
|
|
213
|
+
function captured(r, crumbs) {
|
|
214
|
+
return r.query !== void 0 || !!r.headers || r.body !== void 0 || r.bodySize !== void 0 || crumbs.some((b) => b.category === "network" && b.data?.hasBodies === true);
|
|
215
|
+
}
|
|
216
|
+
/** The request and response the SDK captured on an error, or undefined when it captured none. */
|
|
217
|
+
function exchangeOf(ev) {
|
|
218
|
+
const r = ev.request;
|
|
219
|
+
if (!r || !(captured(r, ev.breadcrumbs ?? []) || ev.response)) return void 0;
|
|
220
|
+
const fullUrl = r.url && !r.url.startsWith("/") ? `https://${r.url}` : void 0;
|
|
221
|
+
return {
|
|
222
|
+
request: {
|
|
223
|
+
method: r.method.toUpperCase(),
|
|
224
|
+
url: r.url,
|
|
225
|
+
fullUrl,
|
|
226
|
+
query: r.query?.replace(/^\?/, "") || void 0,
|
|
227
|
+
...sideOf(r)
|
|
228
|
+
},
|
|
229
|
+
response: ev.response ? {
|
|
230
|
+
status: ev.response.status,
|
|
231
|
+
...sideOf(ev.response)
|
|
232
|
+
} : void 0
|
|
233
|
+
};
|
|
234
|
+
}
|
|
235
|
+
var str$1 = (v) => typeof v === "string" && v ? v : typeof v === "number" ? String(v) : void 0;
|
|
236
|
+
var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : typeof v === "string" && /^\d+$/.test(v) ? Number(v) : void 0;
|
|
237
|
+
/** The first key present: the Cell C app's keys and their alternatives ("backend.title" or "backendTitle"). */
|
|
238
|
+
var pick = (d, ...keys) => keys.map((k) => d[k]).find((v) => v !== void 0 && v !== null && v !== "");
|
|
239
|
+
/** API keys read into the call; the rest of the data is shown as it is. */
|
|
240
|
+
var API_KEYS = /* @__PURE__ */ new Set([
|
|
241
|
+
"service",
|
|
242
|
+
"method",
|
|
243
|
+
"path",
|
|
244
|
+
"url",
|
|
245
|
+
"status",
|
|
246
|
+
"durationMs",
|
|
247
|
+
"outcome",
|
|
248
|
+
"retry",
|
|
249
|
+
"backend.title",
|
|
250
|
+
"backendTitle",
|
|
251
|
+
"backend.code",
|
|
252
|
+
"backendCode",
|
|
253
|
+
"backendErrors",
|
|
254
|
+
"traceId",
|
|
255
|
+
"trace_id",
|
|
256
|
+
"errorKind"
|
|
257
|
+
]);
|
|
258
|
+
/** Outcomes that mean the call did what it should. Anything else the app reports (unreachable, sessionExpired) is a failure. */
|
|
259
|
+
var OK_OUTCOMES = /* @__PURE__ */ new Set([
|
|
260
|
+
"answered",
|
|
261
|
+
"cached",
|
|
262
|
+
"cancelled",
|
|
263
|
+
"canceled",
|
|
264
|
+
"aborted",
|
|
265
|
+
"success",
|
|
266
|
+
"ok"
|
|
267
|
+
]);
|
|
268
|
+
/** The SDK's own network breadcrumb: "POST api.x.com/v1/pay → 503 (120ms)", or "→ failed". */
|
|
269
|
+
var SDK_NETWORK = /^([A-Z]+) (\S+) → (\d{3})?/;
|
|
270
|
+
/** A network breadcrumb as an API call, or undefined when it isn't one ("Device went offline"). */
|
|
271
|
+
function apiCallOf(b, hosts = []) {
|
|
272
|
+
if (b.category !== "network") return void 0;
|
|
273
|
+
const d = b.data ?? {};
|
|
274
|
+
const sdk = SDK_NETWORK.exec(b.message);
|
|
275
|
+
const url = str$1(pick(d, "path", "url")) ?? sdk?.[2];
|
|
276
|
+
const method = str$1(pick(d, "method"))?.toUpperCase() ?? sdk?.[1];
|
|
277
|
+
const appService = str$1(d.service);
|
|
278
|
+
if (!url && !method && !appService) return void 0;
|
|
279
|
+
const status = num(d.status) ?? num(sdk?.[3]);
|
|
280
|
+
const outcome = str$1(d.outcome);
|
|
281
|
+
const named = url && !appService ? hostNameFor(url, hosts) : void 0;
|
|
282
|
+
const call = {
|
|
283
|
+
service: appService ?? named?.host.name,
|
|
284
|
+
method,
|
|
285
|
+
path: named ? named.rest || "/" : url,
|
|
286
|
+
status,
|
|
287
|
+
durationMs: num(d.durationMs),
|
|
288
|
+
outcome,
|
|
289
|
+
retry: typeof d.retry === "boolean" || typeof d.retry === "number" ? d.retry : str$1(d.retry),
|
|
290
|
+
backendTitle: str$1(pick(d, "backend.title", "backendTitle")),
|
|
291
|
+
backendCode: str$1(pick(d, "backend.code", "backendCode")),
|
|
292
|
+
backendErrors: str$1(d.backendErrors),
|
|
293
|
+
errorKind: str$1(d.errorKind),
|
|
294
|
+
traceId: str$1(pick(d, "traceId", "trace_id")),
|
|
295
|
+
failed: false
|
|
296
|
+
};
|
|
297
|
+
call.failed = b.level === "error" || status !== void 0 && status >= 400 || outcome !== void 0 && !OK_OUTCOMES.has(outcome);
|
|
298
|
+
return call;
|
|
299
|
+
}
|
|
300
|
+
/** How close in time the SDK's breadcrumb and the app's own for the same call are. */
|
|
301
|
+
var TWIN_MS = 2e3;
|
|
302
|
+
/**
|
|
303
|
+
* The SDK's own network breadcrumbs that repeat an app breadcrumb for the same call (same method,
|
|
304
|
+
* the SDK's URL ending in the app's path, within TWIN_MS): the app's says more, so the SDK's is
|
|
305
|
+
* left out of the timeline.
|
|
306
|
+
*/
|
|
307
|
+
function sdkTwins(crumbs) {
|
|
308
|
+
const app = crumbs.filter((b) => b.category === "network" && str$1(b.data?.service) && str$1(b.data?.path));
|
|
309
|
+
const out = /* @__PURE__ */ new Set();
|
|
310
|
+
if (!app.length) return out;
|
|
311
|
+
for (const b of crumbs) {
|
|
312
|
+
const sdk = b.category === "network" && !b.data?.service ? SDK_NETWORK.exec(b.message) : null;
|
|
313
|
+
if (!sdk) continue;
|
|
314
|
+
const url = sdk[2].split(/[?#]/)[0];
|
|
315
|
+
const t = Date.parse(b.ts);
|
|
316
|
+
if (app.some((a) => str$1(a.data?.method)?.toUpperCase() === sdk[1] && url.endsWith(String(a.data.path)) && Math.abs(Date.parse(a.ts) - t) <= TWIN_MS)) out.add(b);
|
|
317
|
+
}
|
|
318
|
+
return out;
|
|
319
|
+
}
|
|
320
|
+
/** The breadcrumbs in time order (stable for equal times), each read for what it says. */
|
|
321
|
+
function timelineOf(crumbs = [], hosts = []) {
|
|
322
|
+
return byTime(withoutSdkTwins(crumbs)).map((b) => readCrumb(b, hosts));
|
|
323
|
+
}
|
|
324
|
+
/** Oldest first, stable for equal times. By time, not by string: "09:00:00Z" and "09:00:00.500Z" don't sort as text. */
|
|
325
|
+
function byTime(items) {
|
|
326
|
+
return items.map((x, i) => ({
|
|
327
|
+
x,
|
|
328
|
+
i
|
|
329
|
+
})).sort((p, q) => Date.parse(p.x.ts) - Date.parse(q.x.ts) || p.i - q.i).map(({ x }) => x);
|
|
330
|
+
}
|
|
331
|
+
/** The breadcrumbs without the SDK's own copy of a call the app also described. */
|
|
332
|
+
function withoutSdkTwins(crumbs) {
|
|
333
|
+
const twins = sdkTwins(crumbs);
|
|
334
|
+
return crumbs.filter((b) => !twins.has(b));
|
|
335
|
+
}
|
|
336
|
+
/** One breadcrumb read for what it says: the API call it describes, or its message. */
|
|
337
|
+
function readCrumb(b, hosts = []) {
|
|
338
|
+
const api = apiCallOf(b, hosts);
|
|
339
|
+
const rest = Object.entries(b.data ?? {}).filter(([k]) => k !== "repeated" && !(api && API_KEYS.has(k)));
|
|
340
|
+
const repeated = num(b.data?.repeated);
|
|
341
|
+
return {
|
|
342
|
+
ts: b.ts,
|
|
343
|
+
category: b.category,
|
|
344
|
+
message: nameUrlsIn(b.message, hosts),
|
|
345
|
+
level: b.level,
|
|
346
|
+
failed: api ? api.failed : b.level === "error",
|
|
347
|
+
...api ? { api } : {},
|
|
348
|
+
...rest.length ? { data: Object.fromEntries(rest) } : {},
|
|
349
|
+
...repeated && repeated > 1 ? { repeated } : {}
|
|
350
|
+
};
|
|
351
|
+
}
|
|
352
|
+
/** In-app frames first, keeping stack order within each group. */
|
|
353
|
+
function framesInAppFirst(frames = []) {
|
|
354
|
+
return [...frames.filter((f) => f.inApp), ...frames.filter((f) => !f.inApp)];
|
|
355
|
+
}
|
|
356
|
+
async function buildEventDetail(store, app, fingerprint, eventId) {
|
|
357
|
+
const [issue, events, settings] = await Promise.all([
|
|
358
|
+
store.getIssue(app, fingerprint),
|
|
359
|
+
store.listIssueEvents(app, fingerprint, { limit: 200 }),
|
|
360
|
+
store.getSettings(app).catch(() => null)
|
|
361
|
+
]);
|
|
362
|
+
if (!issue) return null;
|
|
363
|
+
const errors = (events.length ? events : [issue.lastEvent]).filter((e) => e.event.type === "error");
|
|
364
|
+
const index = errors.findIndex((e) => e.event.id === eventId);
|
|
365
|
+
const stored = index >= 0 ? errors[index] : issue.lastEvent.event.id === eventId ? issue.lastEvent : void 0;
|
|
366
|
+
if (!stored || stored.event.type !== "error") return null;
|
|
367
|
+
const ev = stored.event;
|
|
368
|
+
const hosts = settings?.hosts ?? [];
|
|
369
|
+
const timeline = timelineOf(ev.breadcrumbs, hosts);
|
|
370
|
+
return {
|
|
371
|
+
app,
|
|
372
|
+
issue: {
|
|
373
|
+
fingerprint,
|
|
374
|
+
title: nameUrlsIn(issue.title, hosts),
|
|
375
|
+
status: issue.status ?? "open"
|
|
376
|
+
},
|
|
377
|
+
id: ev.id,
|
|
378
|
+
ts: ev.ts,
|
|
379
|
+
handled: ev.handled,
|
|
380
|
+
error: {
|
|
381
|
+
name: ev.error.name,
|
|
382
|
+
message: nameUrlsIn(ev.error.message, hosts)
|
|
383
|
+
},
|
|
384
|
+
flow: ev.flow,
|
|
385
|
+
step: ev.step,
|
|
386
|
+
user: {
|
|
387
|
+
id: stored.user?.id,
|
|
388
|
+
anonymousId: stored.user?.anonymousId
|
|
389
|
+
},
|
|
390
|
+
sessionId: stored.sessionId,
|
|
391
|
+
context: stored.context,
|
|
392
|
+
tags: Object.entries(ev.tags ?? {}).map(([key, value]) => ({
|
|
393
|
+
key,
|
|
394
|
+
value: String(value)
|
|
395
|
+
})).sort((a, b) => a.key.localeCompare(b.key)),
|
|
396
|
+
timeline,
|
|
397
|
+
request: failedRequest(ev.request, timeline, hosts),
|
|
398
|
+
exchange: exchangeOf(ev),
|
|
399
|
+
frames: framesInAppFirst(ev.error.frames),
|
|
400
|
+
stack: ev.error.stack,
|
|
401
|
+
after: await stepsAfter(store, app, stored.sessionId, ev.ts, hosts),
|
|
402
|
+
newer: index > 0 ? errors[index - 1].event.id : void 0,
|
|
403
|
+
older: index >= 0 && index < errors.length - 1 ? errors[index + 1].event.id : void 0
|
|
404
|
+
};
|
|
405
|
+
}
|
|
406
|
+
/**
|
|
407
|
+
* The call that failed: the error's own request, filled in from the app's breadcrumb for the same
|
|
408
|
+
* call (service, backend code, traceId), or the last failing call when the error has no request.
|
|
409
|
+
* A breadcrumb counts as the same call only when its method and path match.
|
|
410
|
+
*/
|
|
411
|
+
function failedRequest(request, timeline, hosts = []) {
|
|
412
|
+
const lastFailing = [...timeline].reverse().find((t) => t.api?.failed)?.api;
|
|
413
|
+
if (!request) return lastFailing;
|
|
414
|
+
const named = hostNameFor(request.url, hosts);
|
|
415
|
+
const own = {
|
|
416
|
+
service: named?.host.name,
|
|
417
|
+
method: request.method.toUpperCase(),
|
|
418
|
+
path: named ? named.rest || "/" : request.url,
|
|
419
|
+
status: request.status,
|
|
420
|
+
durationMs: request.durationMs,
|
|
421
|
+
failed: true
|
|
422
|
+
};
|
|
423
|
+
const bare = request.url.split(/[?#]/)[0];
|
|
424
|
+
const sameCall = (c) => c.method === own.method && !!c.path && (bare.endsWith(c.path) || c.path === own.path);
|
|
425
|
+
const match = [...timeline].reverse().find((t) => t.api?.failed && sameCall(t.api))?.api;
|
|
426
|
+
return match ? {
|
|
427
|
+
...match,
|
|
428
|
+
...defined(own),
|
|
429
|
+
service: match.service ?? own.service,
|
|
430
|
+
path: named ? own.path : match.path
|
|
431
|
+
} : own;
|
|
432
|
+
}
|
|
433
|
+
/** Drop undefined fields, so spreading doesn't erase a value from the breadcrumb. */
|
|
434
|
+
function defined(o) {
|
|
435
|
+
return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
|
|
436
|
+
}
|
|
437
|
+
/**
|
|
438
|
+
* The ways a South African customer number can be stored: 0841234567, 27841234567 and
|
|
439
|
+
* +27841234567 are the same number, typed as any of those, as 0027…, +27 0…, or without the
|
|
440
|
+
* leading 0. Anything else is looked up as typed. Numbers are looked up without spaces.
|
|
441
|
+
*/
|
|
442
|
+
function zaNumberVariants(raw) {
|
|
443
|
+
const q = raw.trim();
|
|
444
|
+
const compact = q.replace(/[\s\-().]/g, "");
|
|
445
|
+
if (!/^\+?\d+$/.test(compact)) return q ? [q] : [];
|
|
446
|
+
const digits = compact.replace(/^\+/, "").replace(/^00(?=27)/, "");
|
|
447
|
+
const national = /^0\d{9}$/.test(digits) ? digits.slice(1) : /^27\d{9}$/.test(digits) ? digits.slice(2) : /^270\d{9}$/.test(digits) ? digits.slice(3) : /^[1-9]\d{8}$/.test(digits) ? digits : void 0;
|
|
448
|
+
const out = national ? [
|
|
449
|
+
`0${national}`,
|
|
450
|
+
`27${national}`,
|
|
451
|
+
`+27${national}`
|
|
452
|
+
] : [digits, `+${digits}`];
|
|
453
|
+
return [.../* @__PURE__ */ new Set([q, ...out])];
|
|
454
|
+
}
|
|
455
|
+
/**
|
|
456
|
+
* A customer's sessions in the given apps, newest first, by customer number in any format or by
|
|
457
|
+
* install id. Android and iOS are often separate apps, so support searches them all at once.
|
|
458
|
+
*/
|
|
459
|
+
async function lookupCustomer(store, apps, raw) {
|
|
460
|
+
const query = raw.trim();
|
|
461
|
+
if (!query) return {
|
|
462
|
+
query,
|
|
463
|
+
matched: [],
|
|
464
|
+
sessions: [],
|
|
465
|
+
truncated: false
|
|
466
|
+
};
|
|
467
|
+
const variants = zaNumberVariants(query);
|
|
468
|
+
const reads = await Promise.all(apps.flatMap((app) => ["id", "anonymousId"].map(async (field) => ({
|
|
469
|
+
field,
|
|
470
|
+
events: await store.listUserEvents(app, field, field === "id" ? variants : [query], { limit: 501 })
|
|
471
|
+
}))));
|
|
472
|
+
const matched = ["id", "anonymousId"].filter((f) => reads.some((r) => r.field === f && r.events.length));
|
|
473
|
+
const truncated = reads.some((r) => r.events.length > 500);
|
|
474
|
+
const events = /* @__PURE__ */ new Map();
|
|
475
|
+
for (const r of reads) for (const e of r.events.slice(0, 500)) events.set(`${e.app}|${e.event.id}`, e);
|
|
476
|
+
return {
|
|
477
|
+
query,
|
|
478
|
+
matched,
|
|
479
|
+
sessions: sessionsOf([...events.values()]),
|
|
480
|
+
truncated
|
|
481
|
+
};
|
|
482
|
+
}
|
|
483
|
+
/** Events grouped by session, newest session first. */
|
|
484
|
+
function sessionsOf(events) {
|
|
485
|
+
const by = /* @__PURE__ */ new Map();
|
|
486
|
+
for (const e of events) {
|
|
487
|
+
const k = `${e.app}|${e.sessionId}`;
|
|
488
|
+
by.set(k, [...by.get(k) ?? [], e]);
|
|
489
|
+
}
|
|
490
|
+
return [...by.values()].map((list) => {
|
|
491
|
+
const sorted = [...list].sort((a, b) => Date.parse(a.event.ts) - Date.parse(b.event.ts));
|
|
492
|
+
const last = sorted[sorted.length - 1];
|
|
493
|
+
return {
|
|
494
|
+
app: last.app,
|
|
495
|
+
sessionId: last.sessionId,
|
|
496
|
+
start: sorted[0].event.ts,
|
|
497
|
+
end: last.event.ts,
|
|
498
|
+
outcome: sessionOutcome(sorted),
|
|
499
|
+
errors: sorted.filter((e) => e.event.type === "error").length,
|
|
500
|
+
handled: sorted.filter((e) => e.event.type === "error" && e.event.handled).length,
|
|
501
|
+
failedFlows: sorted.filter((e) => e.event.type === "event" && e.event.outcome === "failure").length,
|
|
502
|
+
context: last.context,
|
|
503
|
+
user: {
|
|
504
|
+
id: last.user?.id,
|
|
505
|
+
anonymousId: last.user?.anonymousId
|
|
506
|
+
}
|
|
507
|
+
};
|
|
508
|
+
}).sort((a, b) => Date.parse(b.end) - Date.parse(a.end));
|
|
509
|
+
}
|
|
510
|
+
var ISSUE_READ_LIMIT = 500;
|
|
511
|
+
/**
|
|
512
|
+
* The key an endpoint counts under: "<METHOD> <url>" as the SDK's request summaries name it, with
|
|
513
|
+
* the method in capitals and cut where the SDK cuts the summary's key.
|
|
514
|
+
*/
|
|
515
|
+
function endpointKey(method, url) {
|
|
516
|
+
return `${method.toUpperCase()} ${url}`.slice(0, 300);
|
|
517
|
+
}
|
|
518
|
+
/**
|
|
519
|
+
* A stored error that is a failed API call: the SDK's request on it, a request category label, or
|
|
520
|
+
* (a failure the app reported itself) a failed call as its last breadcrumb, just before it.
|
|
521
|
+
*/
|
|
522
|
+
function isNetworkIssue(i) {
|
|
523
|
+
const e = i.lastEvent.event;
|
|
524
|
+
if (e.type !== "error") return false;
|
|
525
|
+
if (e.request || i.lastEvent.labels?.category && isRequestCategory(i.lastEvent.labels.category)) return true;
|
|
526
|
+
const last = e.breadcrumbs?.[e.breadcrumbs.length - 1];
|
|
527
|
+
return !!last && !!apiCallOf(last)?.failed && Math.abs(Date.parse(e.ts) - Date.parse(last.ts)) <= 2e3;
|
|
528
|
+
}
|
|
529
|
+
/**
|
|
530
|
+
* The failed call an error describes, and the endpoint key it counts under: the SDK's request, or
|
|
531
|
+
* for a failure the app reported itself, the request-summary key with the same method and path.
|
|
532
|
+
*/
|
|
533
|
+
function failureOf(e, hosts = [], keys = []) {
|
|
534
|
+
if (e.event.type !== "error") return void 0;
|
|
535
|
+
const req = e.event.request;
|
|
536
|
+
const call = failedRequest(req, timelineOf(e.event.breadcrumbs, hosts), hosts);
|
|
537
|
+
if (req) return {
|
|
538
|
+
endpoint: endpointKey(req.method, req.url),
|
|
539
|
+
call,
|
|
540
|
+
e
|
|
541
|
+
};
|
|
542
|
+
if (!call?.path) return void 0;
|
|
543
|
+
const known = keys.find((k) => sameCall(k, call.method, call.path));
|
|
544
|
+
if (known) return {
|
|
545
|
+
endpoint: known,
|
|
546
|
+
call,
|
|
547
|
+
e
|
|
548
|
+
};
|
|
549
|
+
return {
|
|
550
|
+
endpoint: [
|
|
551
|
+
call.method,
|
|
552
|
+
call.service,
|
|
553
|
+
call.path
|
|
554
|
+
].filter(Boolean).join(" "),
|
|
555
|
+
own: {
|
|
556
|
+
method: call.method,
|
|
557
|
+
path: call.path
|
|
558
|
+
},
|
|
559
|
+
call,
|
|
560
|
+
e
|
|
561
|
+
};
|
|
562
|
+
}
|
|
563
|
+
/** Whether a request-summary key ("<METHOD> <url>") is the call the app names by method and path. */
|
|
564
|
+
function sameCall(key, method, path) {
|
|
565
|
+
const [m, ...rest] = key.split(" ");
|
|
566
|
+
const url = rest.join(" ").split(/[?#]/)[0];
|
|
567
|
+
return (!method || m === method.toUpperCase()) && (url === path || url.endsWith(path.startsWith("/") ? path : `/${path}`));
|
|
568
|
+
}
|
|
569
|
+
/** "503", or the outcome or kind of failure when there was no answer. */
|
|
570
|
+
function statusOf(f) {
|
|
571
|
+
const c = f.call;
|
|
572
|
+
const status = (f.e.event.type === "error" ? f.e.event.request?.status : void 0) ?? c?.status;
|
|
573
|
+
if (status !== void 0) return String(status);
|
|
574
|
+
const timedOut = f.e.event.type === "error" && /timed out|timeout/i.test(f.e.event.error.message);
|
|
575
|
+
return c?.outcome ?? c?.errorKind ?? (timedOut ? "timed out" : "no answer");
|
|
576
|
+
}
|
|
577
|
+
function counts(values) {
|
|
578
|
+
const m = /* @__PURE__ */ new Map();
|
|
579
|
+
for (const v of values) if (v) m.set(v, (m.get(v) ?? 0) + 1);
|
|
580
|
+
return [...m.entries()].map(([key, count]) => ({
|
|
581
|
+
key,
|
|
582
|
+
count
|
|
583
|
+
})).sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
|
|
584
|
+
}
|
|
585
|
+
async function buildEndpoints(store, appParam, now = Date.now(), opts = {}) {
|
|
586
|
+
const apps = await store.listApps();
|
|
587
|
+
const app = appParam && apps.includes(appParam) ? appParam : apps[0];
|
|
588
|
+
if (!app) return null;
|
|
589
|
+
const range = resolveRange(opts.range ?? {}, now);
|
|
590
|
+
const [requestRows, latencyRows, issues, settings, retention] = await Promise.all([
|
|
591
|
+
store.getRollups(app, "requests", range.from, range.to),
|
|
592
|
+
store.getRollups(app, "latency", range.from, range.to),
|
|
593
|
+
store.listIssues(app, { limit: ISSUE_READ_LIMIT }),
|
|
594
|
+
store.getSettings(app).catch(() => null),
|
|
595
|
+
retentionFor(store, app, opts.retentionDays, now)
|
|
596
|
+
]);
|
|
597
|
+
const hosts = settings?.hosts ?? [];
|
|
598
|
+
const network = issues.filter((i) => isNetworkIssue(i) && i.lastSeen.slice(0, 10) >= range.from).sort((a, b) => b.lastSeen.localeCompare(a.lastSeen));
|
|
599
|
+
const read = network.slice(0, 100);
|
|
600
|
+
const perIssue = await Promise.all(read.map((i) => store.listIssueEvents(app, i.fingerprint, { limit: 200 })));
|
|
601
|
+
const events = perIssue.flat();
|
|
602
|
+
const inRange = (e) => e.day >= range.from && e.day <= range.to;
|
|
603
|
+
const capped = perIssue.some((list) => list.length >= 200 && inRange(list[list.length - 1]));
|
|
604
|
+
const timings = /* @__PURE__ */ new Map();
|
|
605
|
+
for (const t of endpointTimings(requestRows, latencyRows, hosts)) {
|
|
606
|
+
const [m, ...rest] = t.endpoint.split(" ");
|
|
607
|
+
timings.set(endpointKey(m, rest.join(" ")), t);
|
|
608
|
+
}
|
|
609
|
+
const failures = events.filter(inRange).map((e) => failureOf(e, hosts, [...timings.keys()])).filter((f) => !!f);
|
|
610
|
+
const byEndpoint = /* @__PURE__ */ new Map();
|
|
611
|
+
for (const f of failures) byEndpoint.set(f.endpoint, [...byEndpoint.get(f.endpoint) ?? [], f]);
|
|
612
|
+
const named = events.flatMap((e) => e.event.type === "error" ? e.event.breadcrumbs ?? [] : []).map((b) => apiCallOf(b, hosts)).filter((c) => !!c?.service && !!c.path);
|
|
613
|
+
const serviceFor = (endpoint) => named.find((c) => sameCall(endpoint, c.method, c.path));
|
|
614
|
+
const rowFor = (endpoint) => {
|
|
615
|
+
const fs = byEndpoint.get(endpoint) ?? [];
|
|
616
|
+
const t = timings.get(endpoint);
|
|
617
|
+
const own = fs.find((f) => f.call?.service)?.call ?? serviceFor(endpoint);
|
|
618
|
+
const fallback = fs.find((f) => f.own)?.own;
|
|
619
|
+
const [first, ...rest] = endpoint.split(" ");
|
|
620
|
+
const method = fallback ? fallback.method : first;
|
|
621
|
+
const url = fallback ? fallback.path : rest.join(" ");
|
|
622
|
+
const host = hostNameFor(url, hosts);
|
|
623
|
+
return {
|
|
624
|
+
endpoint,
|
|
625
|
+
service: own?.service ?? host?.host.name,
|
|
626
|
+
method: own?.method ?? method,
|
|
627
|
+
path: host ? host.rest || "/" : own?.path ?? url,
|
|
628
|
+
calls: t?.requests ?? null,
|
|
629
|
+
failedCalls: t?.failed ?? null,
|
|
630
|
+
failureRate: t ? t.errorRate : null,
|
|
631
|
+
p50: t?.p50 ?? null,
|
|
632
|
+
p95: t?.p95 ?? null,
|
|
633
|
+
failures: fs.length,
|
|
634
|
+
statuses: counts(fs.map(statusOf)),
|
|
635
|
+
backendCodes: counts(fs.map((f) => f.call?.backendCode)),
|
|
636
|
+
lastFailure: fs.map((f) => f.e.event.ts).sort().pop()
|
|
637
|
+
};
|
|
638
|
+
};
|
|
639
|
+
const endpoints = [.../* @__PURE__ */ new Set([...timings.keys(), ...byEndpoint.keys()])].map(rowFor).sort((a, b) => failing(b) - failing(a) || (b.calls ?? 0) - (a.calls ?? 0));
|
|
640
|
+
const chosen = opts.endpoint ? endpoints.find((r) => r.endpoint === opts.endpoint) : void 0;
|
|
641
|
+
const selected = chosen && {
|
|
642
|
+
endpoint: chosen,
|
|
643
|
+
failures: (byEndpoint.get(chosen.endpoint) ?? []).sort((a, b) => Date.parse(b.e.event.ts) - Date.parse(a.e.event.ts)).slice(0, 50).map((f) => ({
|
|
644
|
+
eventId: f.e.event.id,
|
|
645
|
+
fingerprint: f.e.fingerprint,
|
|
646
|
+
ts: f.e.event.ts,
|
|
647
|
+
status: statusOf(f),
|
|
648
|
+
durationMs: f.call?.durationMs,
|
|
649
|
+
errorKind: f.call?.errorKind,
|
|
650
|
+
backendCode: f.call?.backendCode,
|
|
651
|
+
backendTitle: f.call?.backendTitle,
|
|
652
|
+
traceId: f.call?.traceId,
|
|
653
|
+
sessionId: f.e.sessionId,
|
|
654
|
+
userId: f.e.user?.id
|
|
655
|
+
}))
|
|
656
|
+
};
|
|
657
|
+
return {
|
|
658
|
+
app,
|
|
659
|
+
generatedAt: new Date(now).toISOString(),
|
|
660
|
+
apps,
|
|
661
|
+
range,
|
|
662
|
+
retention,
|
|
663
|
+
services: servicesOf(endpoints),
|
|
664
|
+
endpoints,
|
|
665
|
+
selected,
|
|
666
|
+
missing: opts.endpoint && !chosen ? opts.endpoint : void 0,
|
|
667
|
+
truncated: issues.length >= ISSUE_READ_LIMIT || network.length > read.length || capped
|
|
668
|
+
};
|
|
669
|
+
}
|
|
670
|
+
/** How badly an endpoint fails: the larger of the SDK's failed calls and the stored failures. */
|
|
671
|
+
var failing = (r) => Math.max(r.failedCalls ?? 0, r.failures);
|
|
672
|
+
/** Endpoints added up per service, most failures first. */
|
|
673
|
+
function servicesOf(endpoints) {
|
|
674
|
+
const by = /* @__PURE__ */ new Map();
|
|
675
|
+
for (const e of endpoints) by.set(e.service, [...by.get(e.service) ?? [], e]);
|
|
676
|
+
return [...by.entries()].map(([service, list]) => {
|
|
677
|
+
const calls = list.reduce((n, e) => n + (e.calls ?? 0), 0);
|
|
678
|
+
const failedCalls = list.reduce((n, e) => n + (e.failedCalls ?? 0), 0);
|
|
679
|
+
const p95s = list.map((e) => e.p95).filter((v) => v !== null);
|
|
680
|
+
return {
|
|
681
|
+
service,
|
|
682
|
+
endpoints: list.length,
|
|
683
|
+
calls,
|
|
684
|
+
failedCalls,
|
|
685
|
+
failureRate: calls ? failedCalls / calls : null,
|
|
686
|
+
worstP95: p95s.length ? Math.max(...p95s) : null,
|
|
687
|
+
failures: list.reduce((n, e) => n + e.failures, 0)
|
|
688
|
+
};
|
|
689
|
+
}).sort((a, b) => failing(b) - failing(a) || b.calls - a.calls);
|
|
690
|
+
}
|
|
691
|
+
// src/server/team.ts
|
|
692
|
+
async function run(action, body) {
|
|
693
|
+
const writer = settingsWriter();
|
|
694
|
+
let out;
|
|
695
|
+
if (writer === "local") out = await teamAction(await getLocalWriteStore(), action, body);
|
|
696
|
+
else if (writer === "admin") {
|
|
697
|
+
const c = config();
|
|
698
|
+
const res = await fetch(`${c.adminUrl}/team/${action}`, {
|
|
699
|
+
method: "POST",
|
|
700
|
+
headers: {
|
|
701
|
+
authorization: `Bearer ${c.adminToken}`,
|
|
702
|
+
"content-type": "application/json"
|
|
703
|
+
},
|
|
704
|
+
body: JSON.stringify(body)
|
|
705
|
+
});
|
|
706
|
+
out = {
|
|
707
|
+
status: res.status,
|
|
708
|
+
body: await res.json().catch(() => ({ error: `The ingest function answered ${res.status}` }))
|
|
709
|
+
};
|
|
710
|
+
if (res.status === 404 && out.body.error === "not found") throw new Error("Your ingest function is older than this dashboard. Redeploy it (npx debugkit init) to manage the team.");
|
|
711
|
+
} else throw new Error("The team can't be changed from this dashboard: DEBUG_ADMIN_URL and DEBUG_ADMIN_TOKEN aren't set.");
|
|
712
|
+
if (out.status >= 400) throw new Error(String(out.body.error ?? "That didn't work."));
|
|
713
|
+
if (typeof body.email === "string") forgetMember(body.email.toLowerCase());
|
|
714
|
+
return out.body;
|
|
715
|
+
}
|
|
716
|
+
var pending = (i, now = Date.now()) => !i.usedAt && !i.revokedAt && Date.parse(i.expiresAt) > now;
|
|
717
|
+
async function teamMembers() {
|
|
718
|
+
const store = await getStore();
|
|
719
|
+
return typeof store.listMembers === "function" ? store.listMembers() : [];
|
|
720
|
+
}
|
|
721
|
+
async function readTeam() {
|
|
722
|
+
const store = await getStore();
|
|
723
|
+
const env = new Set(envOwnerEmails());
|
|
724
|
+
const [members, invites] = await Promise.all([teamMembers(), typeof store.listInvites === "function" ? store.listInvites() : Promise.resolve([])]);
|
|
725
|
+
const writer = settingsWriter();
|
|
726
|
+
return {
|
|
727
|
+
members: [...[...env].map((email) => ({
|
|
728
|
+
email,
|
|
729
|
+
role: "owner",
|
|
730
|
+
source: "env"
|
|
731
|
+
})), ...members.filter((m) => !m.removedAt && !env.has(m.email)).map((m) => ({
|
|
732
|
+
email: m.email,
|
|
733
|
+
name: m.name,
|
|
734
|
+
role: m.role,
|
|
735
|
+
source: "team",
|
|
736
|
+
createdAt: m.createdAt,
|
|
737
|
+
invitedBy: m.invitedBy
|
|
738
|
+
}))],
|
|
739
|
+
invites: invites.filter((i) => pending(i)).map(({ id, role, email, invitedBy, createdAt, expiresAt }) => ({
|
|
740
|
+
id,
|
|
741
|
+
role,
|
|
742
|
+
email,
|
|
743
|
+
invitedBy,
|
|
744
|
+
createdAt,
|
|
745
|
+
expiresAt
|
|
746
|
+
})),
|
|
747
|
+
canWrite: writer !== "none",
|
|
748
|
+
note: writer === "none" ? "Inviting people needs DEBUG_ADMIN_URL and DEBUG_ADMIN_TOKEN (npx debugkit init sets them)." : void 0
|
|
749
|
+
};
|
|
750
|
+
}
|
|
751
|
+
/** Owners can do anything; admins can't create, change or remove owners. */
|
|
752
|
+
function allowed(actor, targetRole, newRole) {
|
|
753
|
+
if (actor.role === "owner") return;
|
|
754
|
+
if (actor.role !== "admin") throw new Error("Only owners and admins can manage the team.");
|
|
755
|
+
if (targetRole === "owner" || newRole === "owner") throw new Error("Only an owner can add, change or remove owners.");
|
|
756
|
+
}
|
|
757
|
+
/** At least one owner must remain who can sign in. */
|
|
758
|
+
async function keepsAnOwner(email) {
|
|
759
|
+
if (envOwnerEmails().length) return;
|
|
760
|
+
if (!(await teamMembers()).filter((m) => !m.removedAt && m.role === "owner" && m.email !== email).length) throw new Error("This is the last owner. Make someone else an owner first.");
|
|
761
|
+
}
|
|
762
|
+
async function createInvite(actor, role, email) {
|
|
763
|
+
allowed(actor, void 0, role);
|
|
764
|
+
if (email && envOwnerEmails().includes(email.toLowerCase())) throw new Error(`${email} already has access.`);
|
|
765
|
+
const out = await run("invite", {
|
|
766
|
+
role,
|
|
767
|
+
email,
|
|
768
|
+
invitedBy: actor.email
|
|
769
|
+
});
|
|
770
|
+
return {
|
|
771
|
+
token: String(out.token),
|
|
772
|
+
expiresAt: String(out.invite.expiresAt)
|
|
773
|
+
};
|
|
774
|
+
}
|
|
775
|
+
async function revokeInvite(actor, id) {
|
|
776
|
+
allowed(actor, (await (await getStore()).listInvites()).find((x) => x.id === id)?.role);
|
|
777
|
+
await run("revoke", { id });
|
|
778
|
+
}
|
|
779
|
+
async function target(email) {
|
|
780
|
+
const m = (await teamMembers()).find((x) => x.email === email && !x.removedAt);
|
|
781
|
+
if (!m) throw new Error(envOwnerEmails().includes(email) ? "This login is set in the dashboard's settings (DEBUG_DASHBOARD_USERS); change it there." : "No such member.");
|
|
782
|
+
return m;
|
|
783
|
+
}
|
|
784
|
+
async function changeRole(actor, email, role) {
|
|
785
|
+
const m = await target(email);
|
|
786
|
+
allowed(actor, m.role, role);
|
|
787
|
+
if (m.role === "owner" && role !== "owner") await keepsAnOwner(email);
|
|
788
|
+
await run("role", {
|
|
789
|
+
email,
|
|
790
|
+
role
|
|
791
|
+
});
|
|
792
|
+
}
|
|
793
|
+
async function removeMember(actor, email) {
|
|
794
|
+
const m = await target(email);
|
|
795
|
+
allowed(actor, m.role);
|
|
796
|
+
if (m.role === "owner") await keepsAnOwner(email);
|
|
797
|
+
await run("remove", { email });
|
|
798
|
+
}
|
|
799
|
+
/** Someone opening an invite link: make their login. Returns what the session needs. */
|
|
800
|
+
async function acceptInvite(token, email, name, password) {
|
|
801
|
+
if (password.length < 10) throw new Error("Use at least 10 characters for your password.");
|
|
802
|
+
if (password.length > 200) throw new Error("That password is too long.");
|
|
803
|
+
if (envOwnerEmails().includes(email.trim().toLowerCase())) throw new Error(`${email} already has access. Sign in instead.`);
|
|
804
|
+
const m = (await run("accept", {
|
|
805
|
+
token,
|
|
806
|
+
email,
|
|
807
|
+
name,
|
|
808
|
+
passwordHash: hashPassword(password)
|
|
809
|
+
})).member;
|
|
810
|
+
return {
|
|
811
|
+
email: m.email,
|
|
812
|
+
role: m.role,
|
|
813
|
+
name: m.name,
|
|
814
|
+
source: "team",
|
|
815
|
+
v: m.sessionVersion
|
|
816
|
+
};
|
|
817
|
+
}
|
|
818
|
+
// src/server/fns.ts?tss-serverfn-split
|
|
819
|
+
var getSessionUser_createServerFn_handler = createServerRpc({
|
|
820
|
+
id: "1edaae661b4968edee65ebb4a946e246107684704b784b6359bf9af2dfaae23f",
|
|
821
|
+
name: "getSessionUser",
|
|
822
|
+
filename: "src/server/fns.ts"
|
|
823
|
+
}, (opts) => getSessionUser.__executeServer(opts));
|
|
824
|
+
var getSessionUser = createServerFn({ method: "GET" }).handler(getSessionUser_createServerFn_handler, async () => readSession());
|
|
825
|
+
var getLoginInfo_createServerFn_handler = createServerRpc({
|
|
826
|
+
id: "949e1fa91e479f6ad9193caee7087c38ca21191786f4b2c082ea643cbd30dec1",
|
|
827
|
+
name: "getLoginInfo",
|
|
828
|
+
filename: "src/server/fns.ts"
|
|
829
|
+
}, (opts) => getLoginInfo.__executeServer(opts));
|
|
830
|
+
var getLoginInfo = createServerFn({ method: "GET" }).handler(getLoginInfo_createServerFn_handler, async () => ({
|
|
831
|
+
store: config().store,
|
|
832
|
+
demo: demoLoginEnabled() ? DEMO_USER : null
|
|
833
|
+
}));
|
|
834
|
+
var login_createServerFn_handler = createServerRpc({
|
|
835
|
+
id: "a9edf8f42685a06ce282bb7c9f888e3ae39636f350a90750c31a47b27de7dca8",
|
|
836
|
+
name: "login",
|
|
837
|
+
filename: "src/server/fns.ts"
|
|
838
|
+
}, (opts) => login.__executeServer(opts));
|
|
839
|
+
var login = createServerFn({ method: "POST" }).validator((d) => {
|
|
840
|
+
if (typeof d?.email !== "string" || typeof d?.password !== "string") throw new Error("email and password required");
|
|
841
|
+
return {
|
|
842
|
+
email: d.email.slice(0, 200),
|
|
843
|
+
password: d.password.slice(0, 200)
|
|
844
|
+
};
|
|
845
|
+
}).handler(login_createServerFn_handler, async ({ data }) => {
|
|
846
|
+
const key = data.email.trim().toLowerCase();
|
|
847
|
+
if (tooManyAttempts(key)) return {
|
|
848
|
+
ok: false,
|
|
849
|
+
error: "Too many attempts. Wait 15 minutes, or ask an owner to reset your access."
|
|
850
|
+
};
|
|
851
|
+
const user = await checkCredentials(data.email, data.password);
|
|
852
|
+
if (!user) {
|
|
853
|
+
recordFailure(key);
|
|
854
|
+
await new Promise((r) => setTimeout(r, 400));
|
|
855
|
+
return {
|
|
856
|
+
ok: false,
|
|
857
|
+
error: "Incorrect email or password."
|
|
858
|
+
};
|
|
859
|
+
}
|
|
860
|
+
startSession(user);
|
|
861
|
+
return { ok: true };
|
|
862
|
+
});
|
|
863
|
+
var logout_createServerFn_handler = createServerRpc({
|
|
864
|
+
id: "fd40d9026eb7d8fb5ab200daaed9a58f1d7b4eaf5b1ccab3e4cef9b0fedd9bc4",
|
|
865
|
+
name: "logout",
|
|
866
|
+
filename: "src/server/fns.ts"
|
|
867
|
+
}, (opts) => logout.__executeServer(opts));
|
|
868
|
+
var logout = createServerFn({ method: "POST" }).handler(logout_createServerFn_handler, async () => {
|
|
869
|
+
endSession();
|
|
870
|
+
return { ok: true };
|
|
871
|
+
});
|
|
872
|
+
async function requireUser() {
|
|
873
|
+
const user = await readSession();
|
|
874
|
+
if (!user) throw redirect({ to: "/login" });
|
|
875
|
+
return user;
|
|
876
|
+
}
|
|
877
|
+
/** Settings and the team: owners and admins only. */
|
|
878
|
+
async function requireManager() {
|
|
879
|
+
const user = await requireUser();
|
|
880
|
+
if (!canManage(user)) throw new Error("Only owners and admins can change this.");
|
|
881
|
+
return user;
|
|
882
|
+
}
|
|
883
|
+
var str = (v) => typeof v === "string" && v.length <= 32 ? v : void 0;
|
|
884
|
+
var rangeOf = (d) => ({
|
|
885
|
+
range: str(d?.range),
|
|
886
|
+
from: str(d?.from),
|
|
887
|
+
to: str(d?.to)
|
|
888
|
+
});
|
|
889
|
+
var getOverview_createServerFn_handler = createServerRpc({
|
|
890
|
+
id: "9354c2231554471ec5cde4e9a07b2e32662a8ce0bf29b09b5b930359d374f862",
|
|
891
|
+
name: "getOverview",
|
|
892
|
+
filename: "src/server/fns.ts"
|
|
893
|
+
}, (opts) => getOverview.__executeServer(opts));
|
|
894
|
+
var getOverview = createServerFn({ method: "GET" }).validator((d) => ({
|
|
895
|
+
app: str(d?.app),
|
|
896
|
+
...rangeOf(d)
|
|
897
|
+
})).handler(getOverview_createServerFn_handler, async ({ data }) => {
|
|
898
|
+
await requireUser();
|
|
899
|
+
return buildSummary(await getStore(), data.app, config().severity, Date.now(), {
|
|
900
|
+
range: data,
|
|
901
|
+
retentionDays: config().retentionDays
|
|
902
|
+
});
|
|
903
|
+
});
|
|
904
|
+
var getEndpoints_createServerFn_handler = createServerRpc({
|
|
905
|
+
id: "8ade0e7bba4102fdb7cbe0494762fbb0d01a480c84a69f325fc76686a0dc0237",
|
|
906
|
+
name: "getEndpoints",
|
|
907
|
+
filename: "src/server/fns.ts"
|
|
908
|
+
}, (opts) => getEndpoints.__executeServer(opts));
|
|
909
|
+
var getEndpoints = createServerFn({ method: "GET" }).validator((d) => ({
|
|
910
|
+
app: str(d?.app),
|
|
911
|
+
endpoint: str(d?.endpoint)?.slice(0, 400),
|
|
912
|
+
...rangeOf(d)
|
|
913
|
+
})).handler(getEndpoints_createServerFn_handler, async ({ data }) => {
|
|
914
|
+
await requireUser();
|
|
915
|
+
return buildEndpoints(await getStore(), data.app, Date.now(), {
|
|
916
|
+
range: data,
|
|
917
|
+
endpoint: data.endpoint,
|
|
918
|
+
retentionDays: config().retentionDays
|
|
919
|
+
});
|
|
920
|
+
});
|
|
921
|
+
var getIssueDetail_createServerFn_handler = createServerRpc({
|
|
922
|
+
id: "86933afdbcaa1be4a0aa07c4f8e690fdd684edbeab02a49ffdb73e85cadf9933",
|
|
923
|
+
name: "getIssueDetail",
|
|
924
|
+
filename: "src/server/fns.ts"
|
|
925
|
+
}, (opts) => getIssueDetail.__executeServer(opts));
|
|
926
|
+
var getIssueDetail = createServerFn({ method: "GET" }).validator((d) => ({
|
|
927
|
+
app: String(d.app),
|
|
928
|
+
fingerprint: String(d.fingerprint),
|
|
929
|
+
...rangeOf(d)
|
|
930
|
+
})).handler(getIssueDetail_createServerFn_handler, async ({ data }) => {
|
|
931
|
+
await requireUser();
|
|
932
|
+
const detail = await buildIssueDetail(await getStore(), data.app, data.fingerprint, config().severity, Date.now(), {
|
|
933
|
+
range: data,
|
|
934
|
+
retentionDays: config().retentionDays,
|
|
935
|
+
trackers: config().trackers
|
|
936
|
+
});
|
|
937
|
+
return detail ? {
|
|
938
|
+
...detail,
|
|
939
|
+
canChangeStatus: settingsWriter() !== "none"
|
|
940
|
+
} : null;
|
|
941
|
+
});
|
|
942
|
+
var getEventDetail_createServerFn_handler = createServerRpc({
|
|
943
|
+
id: "8fc5d548afdc47f30ea4f9fab6f96cf926fd407c0b80ea68c796b6de7e606a4e",
|
|
944
|
+
name: "getEventDetail",
|
|
945
|
+
filename: "src/server/fns.ts"
|
|
946
|
+
}, (opts) => getEventDetail.__executeServer(opts));
|
|
947
|
+
var getEventDetail = createServerFn({ method: "GET" }).validator((d) => ({
|
|
948
|
+
app: String(d.app),
|
|
949
|
+
fingerprint: String(d.fingerprint),
|
|
950
|
+
eventId: String(d.eventId)
|
|
951
|
+
})).handler(getEventDetail_createServerFn_handler, async ({ data }) => {
|
|
952
|
+
await requireUser();
|
|
953
|
+
return buildEventDetail(await getStore(), data.app, data.fingerprint, data.eventId);
|
|
954
|
+
});
|
|
955
|
+
var getSessionDetail_createServerFn_handler = createServerRpc({
|
|
956
|
+
id: "a4d3bc63ce8ef43aeb81dfb47c631fe47d634d298109d6b5865742aff7363696",
|
|
957
|
+
name: "getSessionDetail",
|
|
958
|
+
filename: "src/server/fns.ts"
|
|
959
|
+
}, (opts) => getSessionDetail.__executeServer(opts));
|
|
960
|
+
var getSessionDetail = createServerFn({ method: "GET" }).validator((d) => ({
|
|
961
|
+
app: String(d.app),
|
|
962
|
+
sessionId: String(d.sessionId)
|
|
963
|
+
})).handler(getSessionDetail_createServerFn_handler, async ({ data }) => {
|
|
964
|
+
await requireUser();
|
|
965
|
+
try {
|
|
966
|
+
return { session: await buildSessionDetail(await getStore(), data.app, data.sessionId) };
|
|
967
|
+
} catch (e) {
|
|
968
|
+
if (isMissingIndex(e, config().store)) return {
|
|
969
|
+
session: null,
|
|
970
|
+
missingIndex: true
|
|
971
|
+
};
|
|
972
|
+
throw e;
|
|
973
|
+
}
|
|
974
|
+
});
|
|
975
|
+
var findCustomer_createServerFn_handler = createServerRpc({
|
|
976
|
+
id: "54a67fa946c48ef3e3aaa27c8b323c380b12a14879a00a9567f52e31c358a0ed",
|
|
977
|
+
name: "findCustomer",
|
|
978
|
+
filename: "src/server/fns.ts"
|
|
979
|
+
}, (opts) => findCustomer.__executeServer(opts));
|
|
980
|
+
var findCustomer = createServerFn({ method: "GET" }).validator((d) => ({
|
|
981
|
+
app: typeof d?.app === "string" ? d.app : void 0,
|
|
982
|
+
q: typeof d?.q === "string" ? d.q.slice(0, 100) : ""
|
|
983
|
+
})).handler(findCustomer_createServerFn_handler, async ({ data }) => {
|
|
984
|
+
await requireUser();
|
|
985
|
+
const store = await getStore();
|
|
986
|
+
const apps = await store.listApps();
|
|
987
|
+
const app = data.app && apps.includes(data.app) ? data.app : void 0;
|
|
988
|
+
const base = {
|
|
989
|
+
apps,
|
|
990
|
+
app,
|
|
991
|
+
store: config().store
|
|
992
|
+
};
|
|
993
|
+
try {
|
|
994
|
+
return {
|
|
995
|
+
...base,
|
|
996
|
+
lookup: data.q.trim() && apps.length ? await lookupCustomer(store, app ? [app] : apps, data.q) : null,
|
|
997
|
+
missingIndex: false
|
|
998
|
+
};
|
|
999
|
+
} catch (e) {
|
|
1000
|
+
if (isMissingIndex(e, config().store)) return {
|
|
1001
|
+
...base,
|
|
1002
|
+
lookup: null,
|
|
1003
|
+
missingIndex: true
|
|
1004
|
+
};
|
|
1005
|
+
throw e;
|
|
1006
|
+
}
|
|
1007
|
+
});
|
|
1008
|
+
var updateIssueStatus_createServerFn_handler = createServerRpc({
|
|
1009
|
+
id: "c263ee8bf14396211aeb95bc2b2aec914480b38cc99a9024c1319f932f590f2f",
|
|
1010
|
+
name: "updateIssueStatus",
|
|
1011
|
+
filename: "src/server/fns.ts"
|
|
1012
|
+
}, (opts) => updateIssueStatus.__executeServer(opts));
|
|
1013
|
+
var updateIssueStatus = createServerFn({ method: "POST" }).validator((d) => {
|
|
1014
|
+
const status = d?.status;
|
|
1015
|
+
if (status !== "open" && status !== "resolved" && status !== "ignored") throw new Error("status must be open, resolved or ignored");
|
|
1016
|
+
return {
|
|
1017
|
+
app: String(d.app ?? ""),
|
|
1018
|
+
fingerprint: String(d.fingerprint ?? ""),
|
|
1019
|
+
status,
|
|
1020
|
+
resolvedIn: typeof d.resolvedIn === "string" ? d.resolvedIn.trim().slice(0, 100) || void 0 : void 0
|
|
1021
|
+
};
|
|
1022
|
+
}).handler(updateIssueStatus_createServerFn_handler, async ({ data }) => {
|
|
1023
|
+
await requireUser();
|
|
1024
|
+
try {
|
|
1025
|
+
return {
|
|
1026
|
+
ok: true,
|
|
1027
|
+
...await writeIssueStatus(data.app, data.fingerprint, data.status, data.resolvedIn)
|
|
1028
|
+
};
|
|
1029
|
+
} catch (err) {
|
|
1030
|
+
return {
|
|
1031
|
+
ok: false,
|
|
1032
|
+
error: err.message
|
|
1033
|
+
};
|
|
1034
|
+
}
|
|
1035
|
+
});
|
|
1036
|
+
var getSettings_createServerFn_handler = createServerRpc({
|
|
1037
|
+
id: "e97a9c2b8715ff5e25a9629262b594fb42f11853d6eea78b87305fd0b5155d4d",
|
|
1038
|
+
name: "getSettings",
|
|
1039
|
+
filename: "src/server/fns.ts"
|
|
1040
|
+
}, (opts) => getSettings.__executeServer(opts));
|
|
1041
|
+
var getSettings = createServerFn({ method: "GET" }).validator((d) => ({ app: str(d?.app) })).handler(getSettings_createServerFn_handler, async ({ data }) => {
|
|
1042
|
+
await requireUser();
|
|
1043
|
+
const apps = await (await getStore()).listApps();
|
|
1044
|
+
const app = data.app && apps.includes(data.app) ? data.app : apps[0];
|
|
1045
|
+
const [settings, hosts] = app ? await Promise.all([readSettings(app), seenHosts(app)]) : [null, []];
|
|
1046
|
+
return {
|
|
1047
|
+
apps,
|
|
1048
|
+
settings,
|
|
1049
|
+
seenHosts: hosts
|
|
1050
|
+
};
|
|
1051
|
+
});
|
|
1052
|
+
var saveRetention_createServerFn_handler = createServerRpc({
|
|
1053
|
+
id: "0c2f8fcb35c5e356e4a58fce376bb16efb0e006f519592fdd5f120fa868720cd",
|
|
1054
|
+
name: "saveRetention",
|
|
1055
|
+
filename: "src/server/fns.ts"
|
|
1056
|
+
}, (opts) => saveRetention.__executeServer(opts));
|
|
1057
|
+
var saveRetention = createServerFn({ method: "POST" }).validator((d) => ({
|
|
1058
|
+
app: String(d?.app ?? ""),
|
|
1059
|
+
retentionDays: validRetention(d?.retentionDays)
|
|
1060
|
+
})).handler(saveRetention_createServerFn_handler, async ({ data }) => {
|
|
1061
|
+
await requireManager();
|
|
1062
|
+
try {
|
|
1063
|
+
return {
|
|
1064
|
+
ok: true,
|
|
1065
|
+
settings: await writeRetention(data.app, data.retentionDays)
|
|
1066
|
+
};
|
|
1067
|
+
} catch (err) {
|
|
1068
|
+
return {
|
|
1069
|
+
ok: false,
|
|
1070
|
+
error: err.message
|
|
1071
|
+
};
|
|
1072
|
+
}
|
|
1073
|
+
});
|
|
1074
|
+
var FLOW = /^[a-z0-9_]+(\.[a-z0-9_]+)*$/;
|
|
1075
|
+
var saveAppSettings_createServerFn_handler = createServerRpc({
|
|
1076
|
+
id: "950c0a9412e17ae8308bccd862dee5faea0375153c5ce59491a033dbcb7e7181",
|
|
1077
|
+
name: "saveAppSettings",
|
|
1078
|
+
filename: "src/server/fns.ts"
|
|
1079
|
+
}, (opts) => saveAppSettings.__executeServer(opts));
|
|
1080
|
+
var saveAppSettings = createServerFn({ method: "POST" }).validator((d) => {
|
|
1081
|
+
const flows = Array.isArray(d?.criticalFlows) ? d.criticalFlows.map((f) => String(f).trim().toLowerCase()).filter(Boolean) : void 0;
|
|
1082
|
+
if (flows && (flows.length > 30 || !flows.every((f) => FLOW.test(f) && f.length <= 64))) throw new Error("Flows are dotted lowercase names like checkout.payment (up to 30).");
|
|
1083
|
+
const a = d?.alerts;
|
|
1084
|
+
const hosts = d?.hosts === void 0 ? void 0 : validHostNames(d.hosts);
|
|
1085
|
+
if (typeof hosts === "string") throw new Error(hosts);
|
|
1086
|
+
return {
|
|
1087
|
+
app: String(d?.app ?? ""),
|
|
1088
|
+
criticalFlows: flows,
|
|
1089
|
+
hosts,
|
|
1090
|
+
alerts: a ? {
|
|
1091
|
+
slackWebhookUrl: typeof a.slackWebhookUrl === "string" ? a.slackWebhookUrl.trim().slice(0, 300) : void 0,
|
|
1092
|
+
newIssues: a.newIssues !== false,
|
|
1093
|
+
regressions: a.regressions !== false,
|
|
1094
|
+
onlyCriticalFlows: a.onlyCriticalFlows === true,
|
|
1095
|
+
dashboardUrl: typeof a.dashboardUrl === "string" ? a.dashboardUrl.trim().slice(0, 300) || void 0 : void 0
|
|
1096
|
+
} : void 0
|
|
1097
|
+
};
|
|
1098
|
+
}).handler(saveAppSettings_createServerFn_handler, async ({ data }) => {
|
|
1099
|
+
await requireManager();
|
|
1100
|
+
try {
|
|
1101
|
+
return {
|
|
1102
|
+
ok: true,
|
|
1103
|
+
settings: await writeSettings(data.app, {
|
|
1104
|
+
criticalFlows: data.criticalFlows,
|
|
1105
|
+
alerts: data.alerts,
|
|
1106
|
+
hosts: data.hosts
|
|
1107
|
+
})
|
|
1108
|
+
};
|
|
1109
|
+
} catch (err) {
|
|
1110
|
+
return {
|
|
1111
|
+
ok: false,
|
|
1112
|
+
error: err.message
|
|
1113
|
+
};
|
|
1114
|
+
}
|
|
1115
|
+
});
|
|
1116
|
+
var sendTestAlert_createServerFn_handler = createServerRpc({
|
|
1117
|
+
id: "7028d75aed3e58a91f5f26a3821d0cec6bb478a913058f5aa73cbfb64bbc41d3",
|
|
1118
|
+
name: "sendTestAlert",
|
|
1119
|
+
filename: "src/server/fns.ts"
|
|
1120
|
+
}, (opts) => sendTestAlert.__executeServer(opts));
|
|
1121
|
+
var sendTestAlert = createServerFn({ method: "POST" }).validator((d) => ({ app: String(d?.app ?? "") })).handler(sendTestAlert_createServerFn_handler, async ({ data }) => {
|
|
1122
|
+
await requireManager();
|
|
1123
|
+
try {
|
|
1124
|
+
await testAlert(data.app);
|
|
1125
|
+
return { ok: true };
|
|
1126
|
+
} catch (err) {
|
|
1127
|
+
return {
|
|
1128
|
+
ok: false,
|
|
1129
|
+
error: err.message
|
|
1130
|
+
};
|
|
1131
|
+
}
|
|
1132
|
+
});
|
|
1133
|
+
var restampExisting_createServerFn_handler = createServerRpc({
|
|
1134
|
+
id: "a1b47d616a31acc3132c1bb8258bde961d9c419ff91b2ce1d6479ebb9760b393",
|
|
1135
|
+
name: "restampExisting",
|
|
1136
|
+
filename: "src/server/fns.ts"
|
|
1137
|
+
}, (opts) => restampExisting.__executeServer(opts));
|
|
1138
|
+
var restampExisting = createServerFn({ method: "POST" }).validator((d) => ({
|
|
1139
|
+
app: String(d?.app ?? ""),
|
|
1140
|
+
cursor: str(d?.cursor) ?? (typeof d?.cursor === "string" ? d.cursor.slice(0, 200) : void 0)
|
|
1141
|
+
})).handler(restampExisting_createServerFn_handler, async ({ data }) => {
|
|
1142
|
+
await requireManager();
|
|
1143
|
+
try {
|
|
1144
|
+
return {
|
|
1145
|
+
ok: true,
|
|
1146
|
+
...await restampStep(data.app, data.cursor)
|
|
1147
|
+
};
|
|
1148
|
+
} catch (err) {
|
|
1149
|
+
return {
|
|
1150
|
+
ok: false,
|
|
1151
|
+
error: err.message,
|
|
1152
|
+
updated: 0
|
|
1153
|
+
};
|
|
1154
|
+
}
|
|
1155
|
+
});
|
|
1156
|
+
var role = (v) => {
|
|
1157
|
+
if (!TEAM_ROLES.includes(v)) throw new Error("role must be owner, admin or member");
|
|
1158
|
+
return v;
|
|
1159
|
+
};
|
|
1160
|
+
var emailOf = (v) => typeof v === "string" ? v.trim().toLowerCase().slice(0, 254) : "";
|
|
1161
|
+
var ok = async (fn) => {
|
|
1162
|
+
try {
|
|
1163
|
+
await fn();
|
|
1164
|
+
return { ok: true };
|
|
1165
|
+
} catch (err) {
|
|
1166
|
+
return {
|
|
1167
|
+
ok: false,
|
|
1168
|
+
error: err.message
|
|
1169
|
+
};
|
|
1170
|
+
}
|
|
1171
|
+
};
|
|
1172
|
+
var getTeam_createServerFn_handler = createServerRpc({
|
|
1173
|
+
id: "8ff7e08627330b1c64257ee12b7ed04815853cb3735a9324805c0bcf149bae9f",
|
|
1174
|
+
name: "getTeam",
|
|
1175
|
+
filename: "src/server/fns.ts"
|
|
1176
|
+
}, (opts) => getTeam.__executeServer(opts));
|
|
1177
|
+
var getTeam = createServerFn({ method: "GET" }).handler(getTeam_createServerFn_handler, async () => {
|
|
1178
|
+
const user = await requireUser();
|
|
1179
|
+
return {
|
|
1180
|
+
...await readTeam(),
|
|
1181
|
+
me: user,
|
|
1182
|
+
canManage: canManage(user)
|
|
1183
|
+
};
|
|
1184
|
+
});
|
|
1185
|
+
var inviteToTeam_createServerFn_handler = createServerRpc({
|
|
1186
|
+
id: "0dcf3aa141898f7bb0cefed3e6129613f6226a680cc800b8cb18d2c60b7706fa",
|
|
1187
|
+
name: "inviteToTeam",
|
|
1188
|
+
filename: "src/server/fns.ts"
|
|
1189
|
+
}, (opts) => inviteToTeam.__executeServer(opts));
|
|
1190
|
+
var inviteToTeam = createServerFn({ method: "POST" }).validator((d) => ({
|
|
1191
|
+
role: role(d?.role),
|
|
1192
|
+
email: emailOf(d?.email) || void 0
|
|
1193
|
+
})).handler(inviteToTeam_createServerFn_handler, async ({ data }) => {
|
|
1194
|
+
const user = await requireManager();
|
|
1195
|
+
try {
|
|
1196
|
+
return {
|
|
1197
|
+
ok: true,
|
|
1198
|
+
...await createInvite(user, data.role, data.email)
|
|
1199
|
+
};
|
|
1200
|
+
} catch (err) {
|
|
1201
|
+
return {
|
|
1202
|
+
ok: false,
|
|
1203
|
+
error: err.message
|
|
1204
|
+
};
|
|
1205
|
+
}
|
|
1206
|
+
});
|
|
1207
|
+
var cancelInvite_createServerFn_handler = createServerRpc({
|
|
1208
|
+
id: "b4629be951e5766734fb72f9e1400c19f585a4381d9172539b2512ae5056f4e8",
|
|
1209
|
+
name: "cancelInvite",
|
|
1210
|
+
filename: "src/server/fns.ts"
|
|
1211
|
+
}, (opts) => cancelInvite.__executeServer(opts));
|
|
1212
|
+
var cancelInvite = createServerFn({ method: "POST" }).validator((d) => ({ id: String(d?.id ?? "").slice(0, 64) })).handler(cancelInvite_createServerFn_handler, async ({ data }) => {
|
|
1213
|
+
const user = await requireManager();
|
|
1214
|
+
return ok(() => revokeInvite(user, data.id));
|
|
1215
|
+
});
|
|
1216
|
+
var setMemberRole_createServerFn_handler = createServerRpc({
|
|
1217
|
+
id: "51bfd02b4d1772943ec480c2dcd7b445826bcfa7d494453d269cc82644ea2a42",
|
|
1218
|
+
name: "setMemberRole",
|
|
1219
|
+
filename: "src/server/fns.ts"
|
|
1220
|
+
}, (opts) => setMemberRole.__executeServer(opts));
|
|
1221
|
+
var setMemberRole = createServerFn({ method: "POST" }).validator((d) => ({
|
|
1222
|
+
email: emailOf(d?.email),
|
|
1223
|
+
role: role(d?.role)
|
|
1224
|
+
})).handler(setMemberRole_createServerFn_handler, async ({ data }) => {
|
|
1225
|
+
const user = await requireManager();
|
|
1226
|
+
if (data.email === user.email) return {
|
|
1227
|
+
ok: false,
|
|
1228
|
+
error: "You can't change your own role."
|
|
1229
|
+
};
|
|
1230
|
+
return ok(() => changeRole(user, data.email, data.role));
|
|
1231
|
+
});
|
|
1232
|
+
var removeFromTeam_createServerFn_handler = createServerRpc({
|
|
1233
|
+
id: "2727b9721f5d291dbb62652d2de5cff55fd7871756147d8ce441b03a7a494617",
|
|
1234
|
+
name: "removeFromTeam",
|
|
1235
|
+
filename: "src/server/fns.ts"
|
|
1236
|
+
}, (opts) => removeFromTeam.__executeServer(opts));
|
|
1237
|
+
var removeFromTeam = createServerFn({ method: "POST" }).validator((d) => ({ email: emailOf(d?.email) })).handler(removeFromTeam_createServerFn_handler, async ({ data }) => {
|
|
1238
|
+
const user = await requireManager();
|
|
1239
|
+
if (data.email === user.email) return {
|
|
1240
|
+
ok: false,
|
|
1241
|
+
error: "You can't remove yourself."
|
|
1242
|
+
};
|
|
1243
|
+
return ok(() => removeMember(user, data.email));
|
|
1244
|
+
});
|
|
1245
|
+
var TOKEN = /^[A-Za-z0-9_-]{40,64}$/;
|
|
1246
|
+
/** What an invite link is for, before the person accepts it. Public: the token is the secret. */
|
|
1247
|
+
var getInvite_createServerFn_handler = createServerRpc({
|
|
1248
|
+
id: "8e8646e3fd8b630ba5696313fb01543dc62410ff8fa9b1eea9763286d32c8927",
|
|
1249
|
+
name: "getInvite",
|
|
1250
|
+
filename: "src/server/fns.ts"
|
|
1251
|
+
}, (opts) => getInvite.__executeServer(opts));
|
|
1252
|
+
var getInvite = createServerFn({ method: "GET" }).validator((d) => ({ token: String(d?.token ?? "") })).handler(getInvite_createServerFn_handler, async ({ data }) => {
|
|
1253
|
+
if (!TOKEN.test(data.token)) return { valid: false };
|
|
1254
|
+
const store = await getStore();
|
|
1255
|
+
const id = hashInviteToken(data.token);
|
|
1256
|
+
const i = typeof store.listInvites === "function" ? (await store.listInvites()).find((x) => x.id === id) : void 0;
|
|
1257
|
+
if (!i || i.usedAt || i.revokedAt || Date.parse(i.expiresAt) < Date.now()) return { valid: false };
|
|
1258
|
+
return {
|
|
1259
|
+
valid: true,
|
|
1260
|
+
role: i.role,
|
|
1261
|
+
email: i.email,
|
|
1262
|
+
invitedBy: i.invitedBy,
|
|
1263
|
+
expiresAt: i.expiresAt
|
|
1264
|
+
};
|
|
1265
|
+
});
|
|
1266
|
+
var joinTeam_createServerFn_handler = createServerRpc({
|
|
1267
|
+
id: "2598559c204c178bf26b98a0f3ae20e519cec3b9013f9d9b02ce14b170ada220",
|
|
1268
|
+
name: "joinTeam",
|
|
1269
|
+
filename: "src/server/fns.ts"
|
|
1270
|
+
}, (opts) => joinTeam.__executeServer(opts));
|
|
1271
|
+
var joinTeam = createServerFn({ method: "POST" }).validator((d) => {
|
|
1272
|
+
if (typeof d?.password !== "string") throw new Error("password required");
|
|
1273
|
+
return {
|
|
1274
|
+
token: String(d?.token ?? "").slice(0, 64),
|
|
1275
|
+
email: emailOf(d?.email),
|
|
1276
|
+
name: typeof d?.name === "string" ? d.name.trim().slice(0, 80) || void 0 : void 0,
|
|
1277
|
+
password: d.password
|
|
1278
|
+
};
|
|
1279
|
+
}).handler(joinTeam_createServerFn_handler, async ({ data }) => {
|
|
1280
|
+
if (!TOKEN.test(data.token)) return {
|
|
1281
|
+
ok: false,
|
|
1282
|
+
error: "This invite link isn't valid."
|
|
1283
|
+
};
|
|
1284
|
+
try {
|
|
1285
|
+
const user = await acceptInvite(data.token, data.email, data.name, data.password);
|
|
1286
|
+
startSession(user);
|
|
1287
|
+
return { ok: true };
|
|
1288
|
+
} catch (err) {
|
|
1289
|
+
return {
|
|
1290
|
+
ok: false,
|
|
1291
|
+
error: err.message
|
|
1292
|
+
};
|
|
1293
|
+
}
|
|
1294
|
+
});
|
|
1295
|
+
export { cancelInvite_createServerFn_handler, findCustomer_createServerFn_handler, getEndpoints_createServerFn_handler, getEventDetail_createServerFn_handler, getInvite_createServerFn_handler, getIssueDetail_createServerFn_handler, getLoginInfo_createServerFn_handler, getOverview_createServerFn_handler, getSessionDetail_createServerFn_handler, getSessionUser_createServerFn_handler, getSettings_createServerFn_handler, getTeam_createServerFn_handler, inviteToTeam_createServerFn_handler, joinTeam_createServerFn_handler, login_createServerFn_handler, logout_createServerFn_handler, removeFromTeam_createServerFn_handler, restampExisting_createServerFn_handler, saveAppSettings_createServerFn_handler, saveRetention_createServerFn_handler, sendTestAlert_createServerFn_handler, setMemberRole_createServerFn_handler, updateIssueStatus_createServerFn_handler };
|