notifkit 0.1.14 → 0.1.16
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/dashboard/dist/assets/index-C-DJYu0_.css +1 -0
- package/dashboard/dist/assets/index-CzFZcEon.js +318 -0
- package/dashboard/dist/index.html +2 -2
- package/dist/{bootstrap-m107TukN.mjs → bootstrap-BMDRPjgp.mjs} +1 -1
- package/dist/{bulk-xAd_biYV.mjs → bulk-CJ5QXiPa.mjs} +1 -1
- package/dist/index.d.mts +71 -27
- package/dist/index.mjs +2 -2
- package/dist/{main-CWIBUEc7.mjs → main-6_bXQBDH.mjs} +21 -41
- package/dist/{main-WkxXwP5q.mjs → main-8nP3qmCT.mjs} +29 -49
- package/dist/{main-HT5c6jyf.mjs → main-B82bsFoy.mjs} +183 -334
- package/dist/{main-C87TSAqM.mjs → main-CpaHF1Zw.mjs} +13 -15
- package/dist/{main-DRHL2bst.mjs → main-DULD8-th.mjs} +8 -6
- package/dist/{main-D_62f9fH.mjs → main-ZW5RaiOK.mjs} +77 -64
- package/dist/{main-5kVwbbnW.mjs → main-g1KEcXXp.mjs} +676 -582
- package/dist/{main-C0MjK1Au.mjs → main-mGIT8jv4.mjs} +4 -4
- package/dist/schedule-or-dispatch-Cd7GLfc3.mjs +52 -0
- package/dist/{src-DYqdD694.mjs → src-BE_EUpZ6.mjs} +93 -93
- package/package.json +1 -1
- package/scripts/create-admin.mjs +0 -0
- package/scripts/create-project.mjs +6 -2
- package/scripts/migrate.mjs +0 -0
- package/scripts/notifkit.mjs +0 -0
- package/src/client.ts +3 -3
- package/src/config/index.ts +1 -0
- package/src/contracts/common.ts +2 -0
- package/src/contracts/envelope.ts +1 -1
- package/src/contracts/events/notification-created.ts +2 -0
- package/src/contracts/events/notification-delivered.ts +1 -1
- package/src/contracts/events/notification-failed.ts +1 -1
- package/src/contracts/events/notification-requested.ts +3 -2
- package/src/contracts/helpers.ts +1 -2
- package/src/contracts/index.ts +1 -0
- package/src/contracts/registry.ts +1 -0
- package/src/contracts/sdk.ts +8 -37
- package/src/db/schema.ts +8 -13
- package/src/idempotency/index.ts +6 -8
- package/src/metrics/index.ts +2 -0
- package/src/rate-limiter/api-rate-limiter.ts +208 -0
- package/src/rate-limiter/index.ts +3 -411
- package/src/rate-limiter/project-settings-cache.ts +99 -0
- package/src/rate-limiter/user-throttle.ts +100 -0
- package/src/redis/index.ts +10 -3
- package/src/repositories/admin-user.ts +83 -0
- package/src/repositories/contact.ts +359 -0
- package/src/repositories/index.ts +9 -1416
- package/src/repositories/preference.ts +35 -0
- package/src/repositories/project.ts +110 -0
- package/src/repositories/segment.ts +16 -0
- package/src/repositories/template.ts +72 -0
- package/src/repositories/types.ts +49 -0
- package/src/repositories/user.ts +644 -0
- package/src/repositories/workflow.ts +64 -0
- package/src/services/ai/main.ts +29 -71
- package/src/services/api/admin-static.ts +4 -1
- package/src/services/api/handlers/auth.ts +109 -0
- package/src/services/api/handlers/campaigns.ts +191 -0
- package/src/services/api/handlers/events.ts +99 -0
- package/src/services/api/handlers/notifications.ts +356 -0
- package/src/services/api/handlers/projects.ts +116 -0
- package/src/services/api/handlers/shared.ts +262 -0
- package/src/services/api/handlers/suppressions.ts +95 -0
- package/src/services/api/handlers/system.ts +314 -0
- package/src/services/api/handlers/templates.ts +97 -0
- package/src/services/api/handlers/unsubscribe.ts +215 -0
- package/src/services/api/handlers/users.ts +262 -0
- package/src/services/api/handlers/workflows.ts +150 -0
- package/src/services/api/handlers.ts +25 -2190
- package/src/services/api/health.ts +133 -0
- package/src/services/api/http.ts +12 -0
- package/src/services/api/main.ts +32 -322
- package/src/services/api/router.ts +1 -1
- package/src/services/api/webhooks.ts +172 -0
- package/src/services/delivery/main.ts +256 -498
- package/src/services/engine/main.ts +31 -235
- package/src/services/engine/quiet-hours.ts +151 -0
- package/src/services/engine/schedule-or-dispatch.ts +104 -0
- package/src/services/enricher/main.ts +9 -21
- package/src/services/events/main.ts +2 -2
- package/src/services/scheduler/main.ts +16 -25
- package/src/services/workflow/duration.ts +24 -0
- package/src/services/workflow/main.ts +6 -164
- package/src/services/workflow/timers.ts +157 -0
- package/src/shared/events.ts +3 -2
- package/src/templates/render.ts +1 -0
- package/src/workers/index.ts +7 -4
- package/src/workflows/sdk.ts +1 -0
- package/dashboard/README.md +0 -29
- package/dashboard/dist/assets/index-ggpJKZqZ.js +0 -315
- package/dashboard/dist/assets/index-s-SXGIwv.css +0 -1
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { An as globalEmitter, C as SegmentRepository, D as ContactRepository, Dn as getPriorityBucket, E as TemplateRepository, Ft as CreateWorkflowSchema, Gt as UpdateUserSchema, H as ApiRateLimiter, It as IngestEventSchema, J as StreamProducer, Mt as AddUserSchema, Nt as BatchAddContactsSchema, On as normaliseTarget, Pt as ContactChannelSchema, Rt as NotifyRequestSchema, S as AdminUserRepository, T as ProjectRepository, Ut as TriggerWorkflowSchema, Vt as SyncTemplatesSchema, Wt as UpdateProjectSchema, X as metrics, Xt as CONSUMER_GROUPS, Y as getMetricsRegistry, Yt as buildStreamEvent, Z as createLogger, at as deliveryOutbox, ct as projects, dt as userTopicPreferences, en as PUBSUB_CHANNELS, et as createDatabase, ft as users, g as transportRegistry, gn as readBaseConfig, k as UserRepository, kn as LRUCache, lt as scheduledPayloads, m as verifyUnsubscribeToken, mn as loadEnv, ot as messageLogs, pt as workflowDefinitions, st as projectApiKeys, tn as STREAMS, ut as suppressions, w as WorkflowRepository, z as RedisClient, zt as PreferencesSchema } from "./src-BE_EUpZ6.mjs";
|
|
2
2
|
import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
|
|
3
3
|
import { z } from "zod";
|
|
4
4
|
import { createHash, randomBytes, randomUUID, scrypt, timingSafeEqual } from "node:crypto";
|
|
@@ -60,6 +60,12 @@ async function readJsonBody(req) {
|
|
|
60
60
|
req.on("error", reject);
|
|
61
61
|
});
|
|
62
62
|
}
|
|
63
|
+
function extractAuthToken(req) {
|
|
64
|
+
const authHeader = req.headers["authorization"];
|
|
65
|
+
if (typeof authHeader === "string" && authHeader.toLowerCase().startsWith("bearer ")) return authHeader.slice(7).trim();
|
|
66
|
+
const apiKeyHeader = req.headers["x-api-key"];
|
|
67
|
+
if (typeof apiKeyHeader === "string") return apiKeyHeader.trim();
|
|
68
|
+
}
|
|
63
69
|
function sendJson(res, status, body) {
|
|
64
70
|
const payload = JSON.stringify(body);
|
|
65
71
|
res.writeHead(status, {
|
|
@@ -99,7 +105,7 @@ var HttpError = class extends Error {
|
|
|
99
105
|
*
|
|
100
106
|
* Routes are indexed by `"METHOD:segmentCount"` so `match()` only inspects the
|
|
101
107
|
* small bucket of routes that share the same method and path depth, instead of
|
|
102
|
-
* scanning
|
|
108
|
+
* scanning every registered route on every request.
|
|
103
109
|
*/
|
|
104
110
|
var Router = class {
|
|
105
111
|
/** Indexed buckets: key is `"METHOD:segmentCount"`. */
|
|
@@ -169,84 +175,7 @@ function split(path) {
|
|
|
169
175
|
return path.split("/").filter((s) => s.length > 0);
|
|
170
176
|
}
|
|
171
177
|
//#endregion
|
|
172
|
-
//#region src/services/
|
|
173
|
-
const scryptAsync = promisify(scrypt);
|
|
174
|
-
const DEFAULT_SESSION_TTL_SECONDS = 604800;
|
|
175
|
-
const SESSION_PREFIX = "notif:session:";
|
|
176
|
-
/**
|
|
177
|
-
* Pre-computed dummy hash conforming to salt(16 bytes hex):hash(64 bytes hex).
|
|
178
|
-
* Used during authentication failure to equalize execution time and prevent
|
|
179
|
-
* user enumeration via scrypt timing side-channels.
|
|
180
|
-
*/
|
|
181
|
-
const DUMMY_PASSWORD_HASH = "00000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
|
|
182
|
-
/**
|
|
183
|
-
* Hashes a plaintext password using crypto.scrypt with a random 16-byte salt.
|
|
184
|
-
* Returns salt and hash separated by a colon.
|
|
185
|
-
*/
|
|
186
|
-
async function hashPassword(password) {
|
|
187
|
-
const salt = randomBytes(16).toString("hex");
|
|
188
|
-
return `${salt}:${(await scryptAsync(password, salt, 64)).toString("hex")}`;
|
|
189
|
-
}
|
|
190
|
-
/**
|
|
191
|
-
* Verifies a plaintext password against a stored salt:hash string using constant-time comparison.
|
|
192
|
-
*/
|
|
193
|
-
async function verifyPassword(password, storedHash) {
|
|
194
|
-
const [salt, key] = storedHash.split(":");
|
|
195
|
-
if (!salt || !key) return false;
|
|
196
|
-
const keyBuffer = Buffer.from(key, "hex");
|
|
197
|
-
const derivedKey = await scryptAsync(password, salt, keyBuffer.length);
|
|
198
|
-
if (derivedKey.length !== keyBuffer.length) return false;
|
|
199
|
-
return timingSafeEqual(derivedKey, keyBuffer);
|
|
200
|
-
}
|
|
201
|
-
/**
|
|
202
|
-
* Creates a secure session in Redis for an authenticated admin user.
|
|
203
|
-
*/
|
|
204
|
-
async function createAdminSession(redis, user, ttlSeconds = DEFAULT_SESSION_TTL_SECONDS) {
|
|
205
|
-
const token = `nk_sess_${randomBytes(32).toString("hex")}`;
|
|
206
|
-
const now = Date.now();
|
|
207
|
-
const session = {
|
|
208
|
-
token,
|
|
209
|
-
adminId: user.id,
|
|
210
|
-
email: user.email,
|
|
211
|
-
username: user.username,
|
|
212
|
-
role: user.role,
|
|
213
|
-
createdAt: now,
|
|
214
|
-
expiresAt: now + ttlSeconds * 1e3
|
|
215
|
-
};
|
|
216
|
-
await redis.set(`${SESSION_PREFIX}${token}`, JSON.stringify(session), "EX", ttlSeconds);
|
|
217
|
-
return session;
|
|
218
|
-
}
|
|
219
|
-
/**
|
|
220
|
-
* Retrieves an admin session from Redis if valid and unexpired.
|
|
221
|
-
*/
|
|
222
|
-
async function getAdminSession(redis, token) {
|
|
223
|
-
if (!token || !token.startsWith("nk_sess_")) return null;
|
|
224
|
-
const raw = await redis.get(`${SESSION_PREFIX}${token}`);
|
|
225
|
-
if (!raw) return null;
|
|
226
|
-
try {
|
|
227
|
-
const session = JSON.parse(raw);
|
|
228
|
-
if (session.expiresAt <= Date.now()) {
|
|
229
|
-
await redis.del(`${SESSION_PREFIX}${token}`);
|
|
230
|
-
return null;
|
|
231
|
-
}
|
|
232
|
-
return session;
|
|
233
|
-
} catch {
|
|
234
|
-
return null;
|
|
235
|
-
}
|
|
236
|
-
}
|
|
237
|
-
/**
|
|
238
|
-
* Revokes an active admin session.
|
|
239
|
-
*/
|
|
240
|
-
async function revokeAdminSession(redis, token) {
|
|
241
|
-
if (!token) return;
|
|
242
|
-
await redis.del(`${SESSION_PREFIX}${token}`);
|
|
243
|
-
}
|
|
244
|
-
//#endregion
|
|
245
|
-
//#region src/services/api/handlers.ts
|
|
246
|
-
const IngestEventSchema = z.object({
|
|
247
|
-
name: z.string().min(1),
|
|
248
|
-
properties: z.record(z.string(), z.unknown())
|
|
249
|
-
});
|
|
178
|
+
//#region src/services/api/handlers/shared.ts
|
|
250
179
|
/** Map an inline or user input's contacts and legacy arrays into resolved contact records. */
|
|
251
180
|
function contactsOf(user) {
|
|
252
181
|
const list = [];
|
|
@@ -293,10 +222,8 @@ async function persistUsers(deps, users, projectId) {
|
|
|
293
222
|
preferences: c.preferences ?? {}
|
|
294
223
|
});
|
|
295
224
|
await deps.db.transaction(async (tx) => {
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
await txUserRepo.upsertManyFull(projectId, usersList);
|
|
299
|
-
await txContactRepo.upsertMany(projectId, contactsList);
|
|
225
|
+
await deps.userRepo.withTx(tx).upsertManyFull(projectId, usersList);
|
|
226
|
+
await deps.contactRepo.withTx(tx).upsertMany(projectId, contactsList);
|
|
300
227
|
});
|
|
301
228
|
}
|
|
302
229
|
function parseDlqEntry(id, rawFields) {
|
|
@@ -374,7 +301,9 @@ function parseLimit(ctx, fallback, max = 100) {
|
|
|
374
301
|
const n = parseInt(getQueryParam(ctx, "limit") ?? "", 10);
|
|
375
302
|
return Number.isNaN(n) ? fallback : Math.min(Math.max(n, 1), max);
|
|
376
303
|
}
|
|
377
|
-
|
|
304
|
+
//#endregion
|
|
305
|
+
//#region src/services/api/handlers/templates.ts
|
|
306
|
+
function createTemplatesHandlers(deps) {
|
|
378
307
|
const { logger } = deps;
|
|
379
308
|
async function syncTemplates(req, res, ctx) {
|
|
380
309
|
const parsed = SyncTemplatesSchema.safeParse(await readJsonBody(req));
|
|
@@ -386,10 +315,50 @@ function createHandlers(deps) {
|
|
|
386
315
|
content: t.content,
|
|
387
316
|
aiPrompts: t.aiPrompts
|
|
388
317
|
})));
|
|
389
|
-
for (const t of parsed.data.templates) await deps.redis.native.publish(
|
|
318
|
+
for (const t of parsed.data.templates) await deps.redis.native.publish(PUBSUB_CHANNELS.TEMPLATE_INVALIDATED, `${ctx.projectId}:${t.id}`);
|
|
390
319
|
logger.info({ synced }, "templates synced");
|
|
391
320
|
sendJson(res, 200, { synced });
|
|
392
321
|
}
|
|
322
|
+
async function listTemplates(req, res, ctx) {
|
|
323
|
+
const limit = parseLimit(ctx, void 0);
|
|
324
|
+
const channel = getQueryParam(ctx, "channel");
|
|
325
|
+
const topic = getQueryParam(ctx, "topic");
|
|
326
|
+
let templates = await deps.templateRepo.list(ctx.projectId);
|
|
327
|
+
if (channel) templates = templates.filter((t) => t.channel === channel);
|
|
328
|
+
if (topic) templates = templates.filter((t) => t.topics?.includes(topic));
|
|
329
|
+
if (limit) templates = templates.slice(0, limit);
|
|
330
|
+
sendJson(res, 200, { templates });
|
|
331
|
+
}
|
|
332
|
+
async function getTemplate(req, res, ctx) {
|
|
333
|
+
const templateId = ctx.params.id;
|
|
334
|
+
const template = await deps.templateRepo.findById(ctx.projectId, templateId);
|
|
335
|
+
if (!template) return sendJson(res, 404, {
|
|
336
|
+
error: "template_not_found",
|
|
337
|
+
id: templateId
|
|
338
|
+
});
|
|
339
|
+
sendJson(res, 200, template);
|
|
340
|
+
}
|
|
341
|
+
async function deleteTemplate(req, res, ctx) {
|
|
342
|
+
const templateId = ctx.params.id;
|
|
343
|
+
if (!await deps.templateRepo.delete(ctx.projectId, templateId)) return sendJson(res, 404, {
|
|
344
|
+
error: "template_not_found",
|
|
345
|
+
id: templateId
|
|
346
|
+
});
|
|
347
|
+
await deps.redis.native.publish(PUBSUB_CHANNELS.TEMPLATE_INVALIDATED, `${ctx.projectId}:${templateId}`);
|
|
348
|
+
logger.info({ templateId }, "template deleted");
|
|
349
|
+
sendNoContent(res);
|
|
350
|
+
}
|
|
351
|
+
return {
|
|
352
|
+
syncTemplates,
|
|
353
|
+
listTemplates,
|
|
354
|
+
getTemplate,
|
|
355
|
+
deleteTemplate
|
|
356
|
+
};
|
|
357
|
+
}
|
|
358
|
+
//#endregion
|
|
359
|
+
//#region src/services/api/handlers/users.ts
|
|
360
|
+
function createUsersHandlers(deps) {
|
|
361
|
+
const { logger } = deps;
|
|
393
362
|
async function addUser(req, res, ctx) {
|
|
394
363
|
const parsed = AddUserSchema.safeParse(await readJsonBody(req));
|
|
395
364
|
if (!parsed.success) return sendValidationError(res, parsed.error);
|
|
@@ -484,6 +453,105 @@ function createHandlers(deps) {
|
|
|
484
453
|
}, "contact deleted");
|
|
485
454
|
sendNoContent(res);
|
|
486
455
|
}
|
|
456
|
+
async function getUser(req, res, ctx) {
|
|
457
|
+
const userId = ctx.params.id;
|
|
458
|
+
const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
|
|
459
|
+
if (!user) return sendJson(res, 404, {
|
|
460
|
+
error: "user_not_found",
|
|
461
|
+
id: userId
|
|
462
|
+
});
|
|
463
|
+
const contacts = await deps.contactRepo.findByUserId(ctx.projectId, userId);
|
|
464
|
+
sendJson(res, 200, {
|
|
465
|
+
...user,
|
|
466
|
+
contacts
|
|
467
|
+
});
|
|
468
|
+
}
|
|
469
|
+
async function getUserPreferences(req, res, ctx) {
|
|
470
|
+
const userId = ctx.params.id;
|
|
471
|
+
const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
|
|
472
|
+
if (!user) return sendJson(res, 404, {
|
|
473
|
+
error: "user_not_found",
|
|
474
|
+
id: userId
|
|
475
|
+
});
|
|
476
|
+
sendJson(res, 200, user.preferences);
|
|
477
|
+
}
|
|
478
|
+
async function updateUserPreferences(req, res, ctx) {
|
|
479
|
+
const userId = ctx.params.id;
|
|
480
|
+
const parsed = PreferencesSchema.safeParse(await readJsonBody(req));
|
|
481
|
+
if (!parsed.success) return sendValidationError(res, parsed.error);
|
|
482
|
+
if (!await deps.userRepo.updatePartial(ctx.projectId, userId, { preferences: parsed.data })) return sendJson(res, 404, {
|
|
483
|
+
error: "user_not_found",
|
|
484
|
+
id: userId
|
|
485
|
+
});
|
|
486
|
+
logger.info({ userId }, "user preferences updated");
|
|
487
|
+
sendJson(res, 200, {
|
|
488
|
+
id: userId,
|
|
489
|
+
preferences: parsed.data
|
|
490
|
+
});
|
|
491
|
+
}
|
|
492
|
+
async function listUsers(req, res, ctx) {
|
|
493
|
+
const limit = parseLimit(ctx, 50);
|
|
494
|
+
const cursor = getQueryParam(ctx, "cursor");
|
|
495
|
+
const search = getQueryParam(ctx, "search");
|
|
496
|
+
const segment = getQueryParam(ctx, "segment");
|
|
497
|
+
const language = getQueryParam(ctx, "language");
|
|
498
|
+
const timezone = getQueryParam(ctx, "timezone");
|
|
499
|
+
const channel = getQueryParam(ctx, "channel");
|
|
500
|
+
const filters = search || segment || language || timezone || channel ? {
|
|
501
|
+
search,
|
|
502
|
+
segment,
|
|
503
|
+
language,
|
|
504
|
+
timezone,
|
|
505
|
+
channel
|
|
506
|
+
} : void 0;
|
|
507
|
+
sendJson(res, 200, await deps.userRepo.list(ctx.projectId, limit, cursor, filters));
|
|
508
|
+
}
|
|
509
|
+
async function getUserContacts(req, res, ctx) {
|
|
510
|
+
const userId = ctx.params.id;
|
|
511
|
+
sendJson(res, 200, { contacts: await deps.contactRepo.findByUserId(ctx.projectId, userId) });
|
|
512
|
+
}
|
|
513
|
+
async function listSegments(req, res, ctx) {
|
|
514
|
+
sendJson(res, 200, { segments: await deps.segmentRepo.listSegments(ctx.projectId) });
|
|
515
|
+
}
|
|
516
|
+
async function getUserDetails(_req, res, ctx) {
|
|
517
|
+
const userId = ctx.params.id;
|
|
518
|
+
const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
|
|
519
|
+
if (!user) return sendJson(res, 404, {
|
|
520
|
+
error: "user_not_found",
|
|
521
|
+
id: userId
|
|
522
|
+
});
|
|
523
|
+
const contacts = await deps.contactRepo.findByUserId(ctx.projectId, userId);
|
|
524
|
+
const contactTargets = contacts.map((c) => c.target);
|
|
525
|
+
let logs = [];
|
|
526
|
+
if (contactTargets.length > 0) {
|
|
527
|
+
const sentTo = deps.db.select({ taskId: deliveryOutbox.taskId }).from(deliveryOutbox).where(inArray(deliveryOutbox.destination, contactTargets));
|
|
528
|
+
logs = await deps.db.select().from(messageLogs).where(and(eq(messageLogs.projectId, ctx.projectId), inArray(messageLogs.taskId, sentTo))).orderBy(desc(messageLogs.timestamp)).limit(50);
|
|
529
|
+
}
|
|
530
|
+
sendJson(res, 200, {
|
|
531
|
+
...user,
|
|
532
|
+
contacts,
|
|
533
|
+
logs
|
|
534
|
+
});
|
|
535
|
+
}
|
|
536
|
+
return {
|
|
537
|
+
addUser,
|
|
538
|
+
updateUser,
|
|
539
|
+
deleteUser,
|
|
540
|
+
addContact,
|
|
541
|
+
deleteContact,
|
|
542
|
+
getUser,
|
|
543
|
+
getUserDetails,
|
|
544
|
+
getUserPreferences,
|
|
545
|
+
updateUserPreferences,
|
|
546
|
+
listUsers,
|
|
547
|
+
getUserContacts,
|
|
548
|
+
listSegments
|
|
549
|
+
};
|
|
550
|
+
}
|
|
551
|
+
//#endregion
|
|
552
|
+
//#region src/services/api/handlers/notifications.ts
|
|
553
|
+
function createNotificationsHandlers(deps) {
|
|
554
|
+
const { logger } = deps;
|
|
487
555
|
async function notify(req, res, ctx) {
|
|
488
556
|
const rawBody = await readJsonBody(req);
|
|
489
557
|
const parsed = NotifyRequestSchema.safeParse(rawBody);
|
|
@@ -591,112 +659,6 @@ function createHandlers(deps) {
|
|
|
591
659
|
message: "Task not found or already processed"
|
|
592
660
|
});
|
|
593
661
|
}
|
|
594
|
-
async function triggerWorkflow(req, res, ctx) {
|
|
595
|
-
const parsed = TriggerWorkflowSchema.safeParse(await readJsonBody(req));
|
|
596
|
-
if (!parsed.success) return sendValidationError(res, parsed.error);
|
|
597
|
-
const input = { ...parsed.data.input ?? {} };
|
|
598
|
-
if (parsed.data.user) if (typeof parsed.data.user === "string") input.user = {
|
|
599
|
-
id: parsed.data.user,
|
|
600
|
-
...typeof input.user === "object" && input.user ? input.user : {}
|
|
601
|
-
};
|
|
602
|
-
else {
|
|
603
|
-
try {
|
|
604
|
-
await persistUsers(deps, [parsed.data.user], ctx.projectId);
|
|
605
|
-
} catch (err) {
|
|
606
|
-
deps.logger.error({ err }, "inline user sync for workflow failed");
|
|
607
|
-
}
|
|
608
|
-
input.user = {
|
|
609
|
-
id: parsed.data.user.id,
|
|
610
|
-
...typeof input.user === "object" && input.user ? input.user : {}
|
|
611
|
-
};
|
|
612
|
-
}
|
|
613
|
-
const instanceId = randomUUID();
|
|
614
|
-
const messageId = await deps.producers.workflow.publish(buildStreamEvent("workflow.triggered", {
|
|
615
|
-
projectId: ctx.projectId,
|
|
616
|
-
instanceId,
|
|
617
|
-
name: parsed.data.name,
|
|
618
|
-
input
|
|
619
|
-
}, "api", instanceId));
|
|
620
|
-
logger.info({
|
|
621
|
-
messageId,
|
|
622
|
-
instanceId,
|
|
623
|
-
workflowName: parsed.data.name
|
|
624
|
-
}, "workflow triggered");
|
|
625
|
-
sendJson(res, 202, {
|
|
626
|
-
messageId,
|
|
627
|
-
instanceId
|
|
628
|
-
});
|
|
629
|
-
}
|
|
630
|
-
async function ingestEvent(req, res, ctx) {
|
|
631
|
-
const tsStr = req.headers["x-timestamp"];
|
|
632
|
-
const expiryStr = req.headers["x-expiry"];
|
|
633
|
-
if (tsStr && expiryStr) {
|
|
634
|
-
const now = Date.now();
|
|
635
|
-
const eventTime = new Date(tsStr).getTime();
|
|
636
|
-
const expMs = parseInt(expiryStr, 10) * 1e3;
|
|
637
|
-
if (Number.isNaN(eventTime) || Number.isNaN(expMs)) {
|
|
638
|
-
sendJson(res, 400, {
|
|
639
|
-
error: "invalid_timestamp",
|
|
640
|
-
message: "x-timestamp and x-expiry must be a date and a number of seconds"
|
|
641
|
-
});
|
|
642
|
-
return;
|
|
643
|
-
}
|
|
644
|
-
if (now > eventTime + expMs) {
|
|
645
|
-
sendJson(res, 400, {
|
|
646
|
-
error: "event_expired",
|
|
647
|
-
message: "Webhook event is expired"
|
|
648
|
-
});
|
|
649
|
-
return;
|
|
650
|
-
}
|
|
651
|
-
}
|
|
652
|
-
const parsed = IngestEventSchema.safeParse(await readJsonBody(req));
|
|
653
|
-
if (!parsed.success) return sendValidationError(res, parsed.error);
|
|
654
|
-
const eventId = randomUUID();
|
|
655
|
-
const messageId = await deps.producers.events.publish(buildStreamEvent("event.received", {
|
|
656
|
-
projectId: ctx.projectId,
|
|
657
|
-
eventName: parsed.data.name,
|
|
658
|
-
payload: parsed.data.properties
|
|
659
|
-
}, "api", eventId));
|
|
660
|
-
logger.info({
|
|
661
|
-
messageId,
|
|
662
|
-
eventId,
|
|
663
|
-
eventName: parsed.data.name
|
|
664
|
-
}, "event received");
|
|
665
|
-
sendJson(res, 202, {
|
|
666
|
-
messageId,
|
|
667
|
-
eventId
|
|
668
|
-
});
|
|
669
|
-
}
|
|
670
|
-
async function getEventsStream(req, res, ctx) {
|
|
671
|
-
let open = true;
|
|
672
|
-
let stop;
|
|
673
|
-
req.on("close", () => {
|
|
674
|
-
open = false;
|
|
675
|
-
stop?.();
|
|
676
|
-
});
|
|
677
|
-
const unlisten = await deps.liveEvents.listen((e) => {
|
|
678
|
-
if (!ctx.projectId || e.projectId !== ctx.projectId) return;
|
|
679
|
-
res.write(`event: ${e.event}\n`);
|
|
680
|
-
const data = e.event === "delivery:delivered" ? {
|
|
681
|
-
taskId: e.taskId,
|
|
682
|
-
providerMessageId: e.providerMessageId,
|
|
683
|
-
channel: e.channel
|
|
684
|
-
} : {
|
|
685
|
-
taskId: e.taskId,
|
|
686
|
-
error: e.error,
|
|
687
|
-
channel: e.channel
|
|
688
|
-
};
|
|
689
|
-
res.write(`data: ${JSON.stringify(data)}\n\n`);
|
|
690
|
-
});
|
|
691
|
-
if (!open) return unlisten();
|
|
692
|
-
stop = unlisten;
|
|
693
|
-
res.writeHead(200, {
|
|
694
|
-
"Content-Type": "text/event-stream",
|
|
695
|
-
"Cache-Control": "no-cache",
|
|
696
|
-
Connection: "keep-alive"
|
|
697
|
-
});
|
|
698
|
-
res.write("retry: 10000\n\n");
|
|
699
|
-
}
|
|
700
662
|
async function getNotificationLogs(req, res, ctx) {
|
|
701
663
|
const limit = parseLimit(ctx, 50);
|
|
702
664
|
const cursor = ctx.query.get("cursor");
|
|
@@ -779,40 +741,67 @@ function createHandlers(deps) {
|
|
|
779
741
|
logs
|
|
780
742
|
});
|
|
781
743
|
}
|
|
782
|
-
async function
|
|
783
|
-
const
|
|
784
|
-
const
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
});
|
|
789
|
-
const
|
|
744
|
+
async function getScheduledMessages(_req, res, ctx) {
|
|
745
|
+
const limit = parseLimit(ctx, 50);
|
|
746
|
+
const cursor = getQueryParam(ctx, "cursor");
|
|
747
|
+
const channel = getQueryParam(ctx, "channel");
|
|
748
|
+
const conditions = [sql`(payload->>'projectId') = ${ctx.projectId}`];
|
|
749
|
+
if (cursor) conditions.push(sql`task_id > ${cursor}`);
|
|
750
|
+
if (channel) conditions.push(sql`(payload->>'channel') = ${channel}`);
|
|
751
|
+
const rows = await deps.db.select().from(scheduledPayloads).where(and(...conditions)).orderBy(scheduledPayloads.taskId).limit(limit + 1);
|
|
752
|
+
const hasNext = rows.length > limit;
|
|
753
|
+
const scheduled = hasNext ? rows.slice(0, limit) : rows;
|
|
790
754
|
sendJson(res, 200, {
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
});
|
|
794
|
-
}
|
|
795
|
-
async function getUserPreferences(req, res, ctx) {
|
|
796
|
-
const userId = ctx.params.id;
|
|
797
|
-
const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
|
|
798
|
-
if (!user) return sendJson(res, 404, {
|
|
799
|
-
error: "user_not_found",
|
|
800
|
-
id: userId
|
|
755
|
+
scheduled,
|
|
756
|
+
nextCursor: hasNext && scheduled.length > 0 ? scheduled[scheduled.length - 1].taskId : null
|
|
801
757
|
});
|
|
802
|
-
sendJson(res, 200, user.preferences);
|
|
803
758
|
}
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
759
|
+
return {
|
|
760
|
+
notify,
|
|
761
|
+
cancelNotification,
|
|
762
|
+
getNotificationLogs,
|
|
763
|
+
getNotificationStatus,
|
|
764
|
+
getScheduledMessages
|
|
765
|
+
};
|
|
766
|
+
}
|
|
767
|
+
//#endregion
|
|
768
|
+
//#region src/services/api/handlers/workflows.ts
|
|
769
|
+
function createWorkflowsHandlers(deps) {
|
|
770
|
+
const { logger } = deps;
|
|
771
|
+
async function triggerWorkflow(req, res, ctx) {
|
|
772
|
+
const parsed = TriggerWorkflowSchema.safeParse(await readJsonBody(req));
|
|
807
773
|
if (!parsed.success) return sendValidationError(res, parsed.error);
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
id:
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
|
|
774
|
+
const input = { ...parsed.data.input ?? {} };
|
|
775
|
+
if (parsed.data.user) if (typeof parsed.data.user === "string") input.user = {
|
|
776
|
+
id: parsed.data.user,
|
|
777
|
+
...typeof input.user === "object" && input.user ? input.user : {}
|
|
778
|
+
};
|
|
779
|
+
else {
|
|
780
|
+
try {
|
|
781
|
+
await persistUsers(deps, [parsed.data.user], ctx.projectId);
|
|
782
|
+
} catch (err) {
|
|
783
|
+
deps.logger.error({ err }, "inline user sync for workflow failed");
|
|
784
|
+
}
|
|
785
|
+
input.user = {
|
|
786
|
+
id: parsed.data.user.id,
|
|
787
|
+
...typeof input.user === "object" && input.user ? input.user : {}
|
|
788
|
+
};
|
|
789
|
+
}
|
|
790
|
+
const instanceId = randomUUID();
|
|
791
|
+
const messageId = await deps.producers.workflow.publish(buildStreamEvent("workflow.triggered", {
|
|
792
|
+
projectId: ctx.projectId,
|
|
793
|
+
instanceId,
|
|
794
|
+
name: parsed.data.name,
|
|
795
|
+
input
|
|
796
|
+
}, "api", instanceId));
|
|
797
|
+
logger.info({
|
|
798
|
+
messageId,
|
|
799
|
+
instanceId,
|
|
800
|
+
workflowName: parsed.data.name
|
|
801
|
+
}, "workflow triggered");
|
|
802
|
+
sendJson(res, 202, {
|
|
803
|
+
messageId,
|
|
804
|
+
instanceId
|
|
816
805
|
});
|
|
817
806
|
}
|
|
818
807
|
async function createWorkflow(req, res, ctx) {
|
|
@@ -835,35 +824,6 @@ function createHandlers(deps) {
|
|
|
835
824
|
sendJson(res, 500, { error: "internal_error" });
|
|
836
825
|
}
|
|
837
826
|
}
|
|
838
|
-
async function listTemplates(req, res, ctx) {
|
|
839
|
-
const limit = parseLimit(ctx, void 0);
|
|
840
|
-
const channel = getQueryParam(ctx, "channel");
|
|
841
|
-
const topic = getQueryParam(ctx, "topic");
|
|
842
|
-
let templates = await deps.templateRepo.list(ctx.projectId);
|
|
843
|
-
if (channel) templates = templates.filter((t) => t.channel === channel);
|
|
844
|
-
if (topic) templates = templates.filter((t) => t.topics?.includes(topic));
|
|
845
|
-
if (limit) templates = templates.slice(0, limit);
|
|
846
|
-
sendJson(res, 200, { templates });
|
|
847
|
-
}
|
|
848
|
-
async function getTemplate(req, res, ctx) {
|
|
849
|
-
const templateId = ctx.params.id;
|
|
850
|
-
const template = await deps.templateRepo.findById(ctx.projectId, templateId);
|
|
851
|
-
if (!template) return sendJson(res, 404, {
|
|
852
|
-
error: "template_not_found",
|
|
853
|
-
id: templateId
|
|
854
|
-
});
|
|
855
|
-
sendJson(res, 200, template);
|
|
856
|
-
}
|
|
857
|
-
async function deleteTemplate(req, res, ctx) {
|
|
858
|
-
const templateId = ctx.params.id;
|
|
859
|
-
if (!await deps.templateRepo.delete(ctx.projectId, templateId)) return sendJson(res, 404, {
|
|
860
|
-
error: "template_not_found",
|
|
861
|
-
id: templateId
|
|
862
|
-
});
|
|
863
|
-
await deps.redis.native.publish("template.invalidated", `${ctx.projectId}:${templateId}`);
|
|
864
|
-
logger.info({ templateId }, "template deleted");
|
|
865
|
-
sendNoContent(res);
|
|
866
|
-
}
|
|
867
827
|
async function listWorkflows(req, res, ctx) {
|
|
868
828
|
const limit = parseLimit(ctx, void 0);
|
|
869
829
|
const search = getQueryParam(ctx, "search")?.trim().toLowerCase();
|
|
@@ -890,30 +850,97 @@ function createHandlers(deps) {
|
|
|
890
850
|
logger.info({ instanceId }, "workflow canceled");
|
|
891
851
|
sendNoContent(res);
|
|
892
852
|
}
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
|
|
853
|
+
return {
|
|
854
|
+
triggerWorkflow,
|
|
855
|
+
createWorkflow,
|
|
856
|
+
listWorkflows,
|
|
857
|
+
getWorkflow,
|
|
858
|
+
cancelWorkflow
|
|
859
|
+
};
|
|
860
|
+
}
|
|
861
|
+
//#endregion
|
|
862
|
+
//#region src/services/api/handlers/events.ts
|
|
863
|
+
function createEventsHandlers(deps) {
|
|
864
|
+
const { logger } = deps;
|
|
865
|
+
async function ingestEvent(req, res, ctx) {
|
|
866
|
+
const tsStr = req.headers["x-timestamp"];
|
|
867
|
+
const expiryStr = req.headers["x-expiry"];
|
|
868
|
+
if (tsStr && expiryStr) {
|
|
869
|
+
const now = Date.now();
|
|
870
|
+
const eventTime = new Date(tsStr).getTime();
|
|
871
|
+
const expMs = parseInt(expiryStr, 10) * 1e3;
|
|
872
|
+
if (Number.isNaN(eventTime) || Number.isNaN(expMs)) {
|
|
873
|
+
sendJson(res, 400, {
|
|
874
|
+
error: "invalid_timestamp",
|
|
875
|
+
message: "x-timestamp and x-expiry must be a date and a number of seconds"
|
|
876
|
+
});
|
|
877
|
+
return;
|
|
878
|
+
}
|
|
879
|
+
if (now > eventTime + expMs) {
|
|
880
|
+
sendJson(res, 400, {
|
|
881
|
+
error: "event_expired",
|
|
882
|
+
message: "Webhook event is expired"
|
|
883
|
+
});
|
|
884
|
+
return;
|
|
885
|
+
}
|
|
886
|
+
}
|
|
887
|
+
const parsed = IngestEventSchema.safeParse(await readJsonBody(req));
|
|
888
|
+
if (!parsed.success) return sendValidationError(res, parsed.error);
|
|
889
|
+
const eventId = randomUUID();
|
|
890
|
+
const messageId = await deps.producers.events.publish(buildStreamEvent("event.received", {
|
|
891
|
+
projectId: ctx.projectId,
|
|
892
|
+
eventName: parsed.data.name,
|
|
893
|
+
payload: parsed.data.properties
|
|
894
|
+
}, "api", eventId));
|
|
895
|
+
logger.info({
|
|
896
|
+
messageId,
|
|
897
|
+
eventId,
|
|
898
|
+
eventName: parsed.data.name
|
|
899
|
+
}, "event received");
|
|
900
|
+
sendJson(res, 202, {
|
|
901
|
+
messageId,
|
|
902
|
+
eventId
|
|
903
|
+
});
|
|
913
904
|
}
|
|
914
|
-
async function
|
|
915
|
-
|
|
905
|
+
async function getEventsStream(req, res, ctx) {
|
|
906
|
+
let open = true;
|
|
907
|
+
let stop;
|
|
908
|
+
req.on("close", () => {
|
|
909
|
+
open = false;
|
|
910
|
+
stop?.();
|
|
911
|
+
});
|
|
912
|
+
const unlisten = await deps.liveEvents.listen((e) => {
|
|
913
|
+
if (!ctx.projectId || e.projectId !== ctx.projectId) return;
|
|
914
|
+
res.write(`event: ${e.event}\n`);
|
|
915
|
+
const data = e.event === "delivery:delivered" ? {
|
|
916
|
+
taskId: e.taskId,
|
|
917
|
+
providerMessageId: e.providerMessageId,
|
|
918
|
+
channel: e.channel
|
|
919
|
+
} : {
|
|
920
|
+
taskId: e.taskId,
|
|
921
|
+
error: e.error,
|
|
922
|
+
channel: e.channel
|
|
923
|
+
};
|
|
924
|
+
res.write(`data: ${JSON.stringify(data)}\n\n`);
|
|
925
|
+
});
|
|
926
|
+
if (!open) return unlisten();
|
|
927
|
+
stop = unlisten;
|
|
928
|
+
res.writeHead(200, {
|
|
929
|
+
"Content-Type": "text/event-stream",
|
|
930
|
+
"Cache-Control": "no-cache",
|
|
931
|
+
Connection: "keep-alive"
|
|
932
|
+
});
|
|
933
|
+
res.write("retry: 10000\n\n");
|
|
916
934
|
}
|
|
935
|
+
return {
|
|
936
|
+
ingestEvent,
|
|
937
|
+
getEventsStream
|
|
938
|
+
};
|
|
939
|
+
}
|
|
940
|
+
//#endregion
|
|
941
|
+
//#region src/services/api/handlers/projects.ts
|
|
942
|
+
function createProjectsHandlers(deps) {
|
|
943
|
+
const { logger } = deps;
|
|
917
944
|
async function listProjects(req, res, _ctx) {
|
|
918
945
|
sendJson(res, 200, { projects: await deps.projectRepo.list() });
|
|
919
946
|
}
|
|
@@ -924,11 +951,7 @@ function createHandlers(deps) {
|
|
|
924
951
|
}
|
|
925
952
|
async function updateProject(req, res, ctx) {
|
|
926
953
|
const id = ctx.params.id;
|
|
927
|
-
const parsed =
|
|
928
|
-
rateLimitRpm: z.number().nullable().optional(),
|
|
929
|
-
throttleLimit: z.number().nullable().optional(),
|
|
930
|
-
throttleWindowHours: z.number().nullable().optional()
|
|
931
|
-
}).safeParse(await readJsonBody(req));
|
|
954
|
+
const parsed = UpdateProjectSchema.safeParse(await readJsonBody(req));
|
|
932
955
|
if (!parsed.success) return sendValidationError(res, parsed.error);
|
|
933
956
|
if (!(isUuid(id) && await deps.projectRepo.updateSettings(id, parsed.data))) return sendJson(res, 404, { error: "project_not_found" });
|
|
934
957
|
await deps.redis.native.publish(PUBSUB_CHANNELS.PROJECT_INVALIDATED, id);
|
|
@@ -957,9 +980,22 @@ function createHandlers(deps) {
|
|
|
957
980
|
async function deleteProjectKey(req, res, ctx) {
|
|
958
981
|
const { id, keyId } = ctx.params;
|
|
959
982
|
if (!(isUuid(id) && isUuid(keyId) && await deps.projectRepo.deleteApiKey(id, keyId))) return sendJson(res, 404, { error: "key_not_found" });
|
|
960
|
-
await deps.redis.native.publish(
|
|
983
|
+
await deps.redis.native.publish(PUBSUB_CHANNELS.API_KEY_INVALIDATED, "*");
|
|
961
984
|
sendNoContent(res);
|
|
962
985
|
}
|
|
986
|
+
return {
|
|
987
|
+
listProjects,
|
|
988
|
+
deleteProject,
|
|
989
|
+
updateProject,
|
|
990
|
+
createProjectKey,
|
|
991
|
+
listProjectKeys,
|
|
992
|
+
deleteProjectKey
|
|
993
|
+
};
|
|
994
|
+
}
|
|
995
|
+
//#endregion
|
|
996
|
+
//#region src/services/api/handlers/system.ts
|
|
997
|
+
function createSystemHandlers(deps) {
|
|
998
|
+
const { logger } = deps;
|
|
963
999
|
async function getSystemHealth(_req, res, _ctx) {
|
|
964
1000
|
const keys = [
|
|
965
1001
|
"enricher",
|
|
@@ -1135,7 +1171,7 @@ function createHandlers(deps) {
|
|
|
1135
1171
|
return entry;
|
|
1136
1172
|
}
|
|
1137
1173
|
async function replayDLQMessage(req, res, ctx) {
|
|
1138
|
-
const messageId = (await readJsonBody(req)
|
|
1174
|
+
const messageId = (await readJsonBody(req))?.id;
|
|
1139
1175
|
if (!messageId) {
|
|
1140
1176
|
sendJson(res, 400, { error: "missing_message_id" });
|
|
1141
1177
|
return;
|
|
@@ -1186,41 +1222,18 @@ function createHandlers(deps) {
|
|
|
1186
1222
|
sendJson(res, 500, { error: "delete_failed" });
|
|
1187
1223
|
}
|
|
1188
1224
|
}
|
|
1189
|
-
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
nextCursor: hasNext && scheduled.length > 0 ? scheduled[scheduled.length - 1].taskId : null
|
|
1202
|
-
});
|
|
1203
|
-
}
|
|
1204
|
-
async function getUserDetails(_req, res, ctx) {
|
|
1205
|
-
const userId = ctx.params.id;
|
|
1206
|
-
const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
|
|
1207
|
-
if (!user) return sendJson(res, 404, {
|
|
1208
|
-
error: "user_not_found",
|
|
1209
|
-
id: userId
|
|
1210
|
-
});
|
|
1211
|
-
const contacts = await deps.contactRepo.findByUserId(ctx.projectId, userId);
|
|
1212
|
-
const contactTargets = contacts.map((c) => c.target);
|
|
1213
|
-
let logs = [];
|
|
1214
|
-
if (contactTargets.length > 0) {
|
|
1215
|
-
const sentTo = deps.db.select({ taskId: deliveryOutbox.taskId }).from(deliveryOutbox).where(inArray(deliveryOutbox.destination, contactTargets));
|
|
1216
|
-
logs = await deps.db.select().from(messageLogs).where(and(eq(messageLogs.projectId, ctx.projectId), inArray(messageLogs.taskId, sentTo))).orderBy(desc(messageLogs.timestamp)).limit(50);
|
|
1217
|
-
}
|
|
1218
|
-
sendJson(res, 200, {
|
|
1219
|
-
...user,
|
|
1220
|
-
contacts,
|
|
1221
|
-
logs
|
|
1222
|
-
});
|
|
1223
|
-
}
|
|
1225
|
+
return {
|
|
1226
|
+
getSystemHealth,
|
|
1227
|
+
getSystemMetrics,
|
|
1228
|
+
getDLQMessages,
|
|
1229
|
+
replayDLQMessage,
|
|
1230
|
+
deleteDLQMessage
|
|
1231
|
+
};
|
|
1232
|
+
}
|
|
1233
|
+
//#endregion
|
|
1234
|
+
//#region src/services/api/handlers/unsubscribe.ts
|
|
1235
|
+
function createUnsubscribeHandlers(deps) {
|
|
1236
|
+
const { logger } = deps;
|
|
1224
1237
|
function sendHtml(res, status, body) {
|
|
1225
1238
|
res.writeHead(status, {
|
|
1226
1239
|
"Content-Type": "text/html; charset=utf-8",
|
|
@@ -1310,6 +1323,14 @@ code{background:#f4f4f5;padding:.1rem .35rem;border-radius:4px}</style>
|
|
|
1310
1323
|
}
|
|
1311
1324
|
sendHtml(res, 200, page("You're unsubscribed", `<p>We've stopped sending ${claim.topics.length > 0 ? "these messages" : "messages"} to <code>${escapeHtml(claim.target)}</code>. It may take a few minutes to take effect for mail already on its way.</p>`));
|
|
1312
1325
|
}
|
|
1326
|
+
return {
|
|
1327
|
+
unsubscribePage,
|
|
1328
|
+
unsubscribe
|
|
1329
|
+
};
|
|
1330
|
+
}
|
|
1331
|
+
//#endregion
|
|
1332
|
+
//#region src/services/api/handlers/campaigns.ts
|
|
1333
|
+
function createCampaignsHandlers(deps) {
|
|
1313
1334
|
async function listCampaigns(_req, res, ctx) {
|
|
1314
1335
|
const limit = parseLimit(ctx, 20);
|
|
1315
1336
|
const search = getQueryParam(ctx, "search")?.trim();
|
|
@@ -1410,6 +1431,14 @@ code{background:#f4f4f5;padding:.1rem .35rem;border-radius:4px}</style>
|
|
|
1410
1431
|
warnings
|
|
1411
1432
|
});
|
|
1412
1433
|
}
|
|
1434
|
+
return {
|
|
1435
|
+
listCampaigns,
|
|
1436
|
+
getCampaignStats
|
|
1437
|
+
};
|
|
1438
|
+
}
|
|
1439
|
+
//#endregion
|
|
1440
|
+
//#region src/services/api/handlers/suppressions.ts
|
|
1441
|
+
function createSuppressionsHandlers(deps) {
|
|
1413
1442
|
async function listSuppressions(_req, res, ctx) {
|
|
1414
1443
|
const limit = parseLimit(ctx, 100, 500);
|
|
1415
1444
|
const channel = getQueryParam(ctx, "channel");
|
|
@@ -1453,6 +1482,88 @@ code{background:#f4f4f5;padding:.1rem .35rem;border-radius:4px}</style>
|
|
|
1453
1482
|
await deps.db.delete(suppressions).where(and(eq(suppressions.projectId, ctx.projectId), eq(suppressions.channel, channel), eq(suppressions.target, normaliseTarget(target))));
|
|
1454
1483
|
sendNoContent(res);
|
|
1455
1484
|
}
|
|
1485
|
+
return {
|
|
1486
|
+
listSuppressions,
|
|
1487
|
+
createSuppression,
|
|
1488
|
+
deleteSuppression
|
|
1489
|
+
};
|
|
1490
|
+
}
|
|
1491
|
+
//#endregion
|
|
1492
|
+
//#region src/services/auth/index.ts
|
|
1493
|
+
const scryptAsync = promisify(scrypt);
|
|
1494
|
+
const DEFAULT_SESSION_TTL_SECONDS = 604800;
|
|
1495
|
+
const SESSION_PREFIX = "notif:session:";
|
|
1496
|
+
/**
|
|
1497
|
+
* Pre-computed dummy hash conforming to salt(16 bytes hex):hash(64 bytes hex).
|
|
1498
|
+
* Used during authentication failure to equalize execution time and prevent
|
|
1499
|
+
* user enumeration via scrypt timing side-channels.
|
|
1500
|
+
*/
|
|
1501
|
+
const DUMMY_PASSWORD_HASH = "00000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
|
|
1502
|
+
/**
|
|
1503
|
+
* Hashes a plaintext password using crypto.scrypt with a random 16-byte salt.
|
|
1504
|
+
* Returns salt and hash separated by a colon.
|
|
1505
|
+
*/
|
|
1506
|
+
async function hashPassword(password) {
|
|
1507
|
+
const salt = randomBytes(16).toString("hex");
|
|
1508
|
+
return `${salt}:${(await scryptAsync(password, salt, 64)).toString("hex")}`;
|
|
1509
|
+
}
|
|
1510
|
+
/**
|
|
1511
|
+
* Verifies a plaintext password against a stored salt:hash string using constant-time comparison.
|
|
1512
|
+
*/
|
|
1513
|
+
async function verifyPassword(password, storedHash) {
|
|
1514
|
+
const [salt, key] = storedHash.split(":");
|
|
1515
|
+
if (!salt || !key) return false;
|
|
1516
|
+
const keyBuffer = Buffer.from(key, "hex");
|
|
1517
|
+
const derivedKey = await scryptAsync(password, salt, keyBuffer.length);
|
|
1518
|
+
if (derivedKey.length !== keyBuffer.length) return false;
|
|
1519
|
+
return timingSafeEqual(derivedKey, keyBuffer);
|
|
1520
|
+
}
|
|
1521
|
+
/**
|
|
1522
|
+
* Creates a secure session in Redis for an authenticated admin user.
|
|
1523
|
+
*/
|
|
1524
|
+
async function createAdminSession(redis, user, ttlSeconds = DEFAULT_SESSION_TTL_SECONDS) {
|
|
1525
|
+
const token = `nk_sess_${randomBytes(32).toString("hex")}`;
|
|
1526
|
+
const now = Date.now();
|
|
1527
|
+
const session = {
|
|
1528
|
+
token,
|
|
1529
|
+
adminId: user.id,
|
|
1530
|
+
email: user.email,
|
|
1531
|
+
username: user.username,
|
|
1532
|
+
role: user.role,
|
|
1533
|
+
createdAt: now,
|
|
1534
|
+
expiresAt: now + ttlSeconds * 1e3
|
|
1535
|
+
};
|
|
1536
|
+
await redis.set(`${SESSION_PREFIX}${token}`, JSON.stringify(session), "EX", ttlSeconds);
|
|
1537
|
+
return session;
|
|
1538
|
+
}
|
|
1539
|
+
/**
|
|
1540
|
+
* Retrieves an admin session from Redis if valid and unexpired.
|
|
1541
|
+
*/
|
|
1542
|
+
async function getAdminSession(redis, token) {
|
|
1543
|
+
if (!token || !token.startsWith("nk_sess_")) return null;
|
|
1544
|
+
const raw = await redis.get(`${SESSION_PREFIX}${token}`);
|
|
1545
|
+
if (!raw) return null;
|
|
1546
|
+
try {
|
|
1547
|
+
const session = JSON.parse(raw);
|
|
1548
|
+
if (session.expiresAt <= Date.now()) {
|
|
1549
|
+
await redis.del(`${SESSION_PREFIX}${token}`);
|
|
1550
|
+
return null;
|
|
1551
|
+
}
|
|
1552
|
+
return session;
|
|
1553
|
+
} catch {
|
|
1554
|
+
return null;
|
|
1555
|
+
}
|
|
1556
|
+
}
|
|
1557
|
+
/**
|
|
1558
|
+
* Revokes an active admin session.
|
|
1559
|
+
*/
|
|
1560
|
+
async function revokeAdminSession(redis, token) {
|
|
1561
|
+
if (!token) return;
|
|
1562
|
+
await redis.del(`${SESSION_PREFIX}${token}`);
|
|
1563
|
+
}
|
|
1564
|
+
//#endregion
|
|
1565
|
+
//#region src/services/api/handlers/auth.ts
|
|
1566
|
+
function createAuthHandlers(deps) {
|
|
1456
1567
|
async function login(req, res) {
|
|
1457
1568
|
if (!deps.adminUserRepo) {
|
|
1458
1569
|
sendJson(res, 500, {
|
|
@@ -1530,53 +1641,24 @@ code{background:#f4f4f5;padding:.1rem .35rem;border-radius:4px}</style>
|
|
|
1530
1641
|
return {
|
|
1531
1642
|
login,
|
|
1532
1643
|
logout,
|
|
1533
|
-
getMe
|
|
1534
|
-
|
|
1535
|
-
|
|
1536
|
-
|
|
1537
|
-
|
|
1538
|
-
|
|
1539
|
-
|
|
1540
|
-
|
|
1541
|
-
|
|
1542
|
-
|
|
1543
|
-
|
|
1544
|
-
|
|
1545
|
-
|
|
1546
|
-
|
|
1547
|
-
|
|
1548
|
-
|
|
1549
|
-
|
|
1550
|
-
|
|
1551
|
-
listCampaigns,
|
|
1552
|
-
getCampaignStats,
|
|
1553
|
-
listSuppressions,
|
|
1554
|
-
createSuppression,
|
|
1555
|
-
deleteSuppression,
|
|
1556
|
-
getUserPreferences,
|
|
1557
|
-
updateUserPreferences,
|
|
1558
|
-
listTemplates,
|
|
1559
|
-
getTemplate,
|
|
1560
|
-
deleteTemplate,
|
|
1561
|
-
createWorkflow,
|
|
1562
|
-
listWorkflows,
|
|
1563
|
-
getWorkflow,
|
|
1564
|
-
cancelWorkflow,
|
|
1565
|
-
listUsers,
|
|
1566
|
-
getUserContacts,
|
|
1567
|
-
listSegments,
|
|
1568
|
-
listProjects,
|
|
1569
|
-
deleteProject,
|
|
1570
|
-
updateProject,
|
|
1571
|
-
createProjectKey,
|
|
1572
|
-
listProjectKeys,
|
|
1573
|
-
deleteProjectKey,
|
|
1574
|
-
getSystemHealth,
|
|
1575
|
-
getSystemMetrics,
|
|
1576
|
-
getDLQMessages,
|
|
1577
|
-
replayDLQMessage,
|
|
1578
|
-
deleteDLQMessage,
|
|
1579
|
-
getScheduledMessages
|
|
1644
|
+
getMe
|
|
1645
|
+
};
|
|
1646
|
+
}
|
|
1647
|
+
//#endregion
|
|
1648
|
+
//#region src/services/api/handlers.ts
|
|
1649
|
+
function createHandlers(deps) {
|
|
1650
|
+
return {
|
|
1651
|
+
...createTemplatesHandlers(deps),
|
|
1652
|
+
...createUsersHandlers(deps),
|
|
1653
|
+
...createNotificationsHandlers(deps),
|
|
1654
|
+
...createWorkflowsHandlers(deps),
|
|
1655
|
+
...createEventsHandlers(deps),
|
|
1656
|
+
...createProjectsHandlers(deps),
|
|
1657
|
+
...createSystemHandlers(deps),
|
|
1658
|
+
...createUnsubscribeHandlers(deps),
|
|
1659
|
+
...createCampaignsHandlers(deps),
|
|
1660
|
+
...createSuppressionsHandlers(deps),
|
|
1661
|
+
...createAuthHandlers(deps)
|
|
1580
1662
|
};
|
|
1581
1663
|
}
|
|
1582
1664
|
//#endregion
|
|
@@ -1814,6 +1896,217 @@ var RedisLiveDeliveryEvents = class {
|
|
|
1814
1896
|
}
|
|
1815
1897
|
};
|
|
1816
1898
|
//#endregion
|
|
1899
|
+
//#region src/services/api/health.ts
|
|
1900
|
+
/** GET /health, /metrics, /live and /ready. */
|
|
1901
|
+
function createHealthHandlers({ redis, sql, isAdminApiKey }) {
|
|
1902
|
+
let cachedHealth = null;
|
|
1903
|
+
async function handleHealth(_req, res) {
|
|
1904
|
+
if (cachedHealth && cachedHealth.expiresAt > Date.now()) {
|
|
1905
|
+
sendJson(res, cachedHealth.statusCode, cachedHealth.response);
|
|
1906
|
+
return;
|
|
1907
|
+
}
|
|
1908
|
+
const [redisOk, dbOk] = await Promise.all([redis.healthCheck(), dbHealthCheck()]);
|
|
1909
|
+
const workers = {};
|
|
1910
|
+
let overallOk = redisOk && dbOk;
|
|
1911
|
+
if (redisOk) {
|
|
1912
|
+
const keys = [
|
|
1913
|
+
"enricher",
|
|
1914
|
+
"engine",
|
|
1915
|
+
"scheduler",
|
|
1916
|
+
"delivery",
|
|
1917
|
+
"ai",
|
|
1918
|
+
"workflow",
|
|
1919
|
+
"events"
|
|
1920
|
+
];
|
|
1921
|
+
try {
|
|
1922
|
+
const vals = await redis.native.mget(keys.map((k) => `notif:health:${k}`));
|
|
1923
|
+
for (let i = 0; i < keys.length; i++) {
|
|
1924
|
+
const key = keys[i];
|
|
1925
|
+
const val = vals[i];
|
|
1926
|
+
if (val) {
|
|
1927
|
+
const parsed = JSON.parse(val);
|
|
1928
|
+
workers[key] = parsed;
|
|
1929
|
+
if (parsed.redis === false || parsed.state === "error") overallOk = false;
|
|
1930
|
+
} else workers[key] = {
|
|
1931
|
+
status: "unknown",
|
|
1932
|
+
message: "No report received from worker"
|
|
1933
|
+
};
|
|
1934
|
+
}
|
|
1935
|
+
} catch (err) {
|
|
1936
|
+
for (const key of keys) workers[key] = {
|
|
1937
|
+
status: "error",
|
|
1938
|
+
error: err instanceof Error ? err.message : String(err)
|
|
1939
|
+
};
|
|
1940
|
+
}
|
|
1941
|
+
}
|
|
1942
|
+
const statusCode = overallOk ? 200 : 503;
|
|
1943
|
+
const response = {
|
|
1944
|
+
service: "api",
|
|
1945
|
+
status: overallOk ? "ok" : "degraded",
|
|
1946
|
+
redis: redisOk,
|
|
1947
|
+
database: dbOk,
|
|
1948
|
+
workers
|
|
1949
|
+
};
|
|
1950
|
+
cachedHealth = {
|
|
1951
|
+
response,
|
|
1952
|
+
statusCode,
|
|
1953
|
+
expiresAt: Date.now() + 1e3
|
|
1954
|
+
};
|
|
1955
|
+
sendJson(res, statusCode, response);
|
|
1956
|
+
}
|
|
1957
|
+
async function handleMetrics(req, res) {
|
|
1958
|
+
const remoteIp = req.socket.remoteAddress ?? "";
|
|
1959
|
+
let authorized = remoteIp === "127.0.0.1" || remoteIp === "::1" || remoteIp === "::ffff:127.0.0.1" || remoteIp === "localhost";
|
|
1960
|
+
if (!authorized) {
|
|
1961
|
+
const token = extractAuthToken(req);
|
|
1962
|
+
if (token) {
|
|
1963
|
+
if (token.startsWith("nk_sess_") && redis?.native) {
|
|
1964
|
+
if (await getAdminSession(redis.native, token)) authorized = true;
|
|
1965
|
+
} else if (isAdminApiKey(token)) authorized = true;
|
|
1966
|
+
}
|
|
1967
|
+
}
|
|
1968
|
+
if (!authorized) {
|
|
1969
|
+
sendJson(res, 401, {
|
|
1970
|
+
error: "unauthorized",
|
|
1971
|
+
message: "Metrics endpoint requires admin credentials"
|
|
1972
|
+
});
|
|
1973
|
+
return;
|
|
1974
|
+
}
|
|
1975
|
+
const registry = getMetricsRegistry();
|
|
1976
|
+
res.writeHead(200, { "Content-Type": registry.contentType });
|
|
1977
|
+
res.end(await registry.metrics());
|
|
1978
|
+
}
|
|
1979
|
+
async function handleLive(_req, res) {
|
|
1980
|
+
sendJson(res, 200, { status: "ok" });
|
|
1981
|
+
}
|
|
1982
|
+
async function handleReady(_req, res) {
|
|
1983
|
+
if (cachedHealth && cachedHealth.expiresAt > Date.now()) {
|
|
1984
|
+
sendJson(res, cachedHealth.statusCode === 200 ? 200 : 503, { status: cachedHealth.statusCode === 200 ? "ready" : "unready" });
|
|
1985
|
+
return;
|
|
1986
|
+
}
|
|
1987
|
+
const [redisOk, dbOk] = await Promise.all([redis.healthCheck(), dbHealthCheck()]);
|
|
1988
|
+
const isReady = redisOk && dbOk;
|
|
1989
|
+
sendJson(res, isReady ? 200 : 503, { status: isReady ? "ready" : "unready" });
|
|
1990
|
+
}
|
|
1991
|
+
async function dbHealthCheck() {
|
|
1992
|
+
try {
|
|
1993
|
+
await sql`SELECT 1`;
|
|
1994
|
+
return true;
|
|
1995
|
+
} catch {
|
|
1996
|
+
return false;
|
|
1997
|
+
}
|
|
1998
|
+
}
|
|
1999
|
+
return {
|
|
2000
|
+
handleHealth,
|
|
2001
|
+
handleMetrics,
|
|
2002
|
+
handleLive,
|
|
2003
|
+
handleReady
|
|
2004
|
+
};
|
|
2005
|
+
}
|
|
2006
|
+
//#endregion
|
|
2007
|
+
//#region src/services/api/webhooks.ts
|
|
2008
|
+
/** The POST route a provider delivers webhook events to. */
|
|
2009
|
+
function createWebhookHandler(transport, channel, deps) {
|
|
2010
|
+
const { db, logger } = deps;
|
|
2011
|
+
return async (req, res) => {
|
|
2012
|
+
let deadline;
|
|
2013
|
+
try {
|
|
2014
|
+
await Promise.race([(async () => {
|
|
2015
|
+
const rawBody = await readRawBody(req);
|
|
2016
|
+
if (!transport.verifyWebhook) {
|
|
2017
|
+
if (!res.headersSent) sendJson(res, 501, {
|
|
2018
|
+
error: "not_implemented",
|
|
2019
|
+
message: "Webhook signature verification is not implemented for this provider"
|
|
2020
|
+
});
|
|
2021
|
+
return;
|
|
2022
|
+
}
|
|
2023
|
+
if (!await transport.verifyWebhook(rawBody, req.headers)) {
|
|
2024
|
+
if (!res.headersSent) sendJson(res, 401, {
|
|
2025
|
+
error: "unauthorized",
|
|
2026
|
+
message: "Invalid webhook signature"
|
|
2027
|
+
});
|
|
2028
|
+
return;
|
|
2029
|
+
}
|
|
2030
|
+
let body;
|
|
2031
|
+
try {
|
|
2032
|
+
body = rawBody ? JSON.parse(rawBody) : {};
|
|
2033
|
+
} catch {
|
|
2034
|
+
body = {};
|
|
2035
|
+
}
|
|
2036
|
+
const events = await transport.parseWebhook(body, rawBody, req.headers);
|
|
2037
|
+
if (events.length > 0) {
|
|
2038
|
+
const providerIds = events.map((e) => e.providerMessageId).filter(Boolean);
|
|
2039
|
+
const logsToProject = /* @__PURE__ */ new Map();
|
|
2040
|
+
const logsToTask = /* @__PURE__ */ new Map();
|
|
2041
|
+
const logsToCampaign = /* @__PURE__ */ new Map();
|
|
2042
|
+
if (providerIds.length > 0) {
|
|
2043
|
+
const existing = await db.select({
|
|
2044
|
+
providerMessageId: messageLogs.providerMessageId,
|
|
2045
|
+
projectId: messageLogs.projectId,
|
|
2046
|
+
taskId: messageLogs.taskId,
|
|
2047
|
+
campaignId: messageLogs.campaignId
|
|
2048
|
+
}).from(messageLogs).where(inArray(messageLogs.providerMessageId, providerIds));
|
|
2049
|
+
for (const row of existing) if (row.providerMessageId) {
|
|
2050
|
+
logsToProject.set(row.providerMessageId, row.projectId);
|
|
2051
|
+
logsToTask.set(row.providerMessageId, row.taskId);
|
|
2052
|
+
logsToCampaign.set(row.providerMessageId, row.campaignId);
|
|
2053
|
+
}
|
|
2054
|
+
}
|
|
2055
|
+
const attributable = events.filter((e) => e.providerMessageId && logsToProject.has(e.providerMessageId));
|
|
2056
|
+
const rows = attributable.map((e) => ({
|
|
2057
|
+
projectId: logsToProject.get(e.providerMessageId),
|
|
2058
|
+
taskId: logsToTask.get(e.providerMessageId),
|
|
2059
|
+
providerMessageId: e.providerMessageId,
|
|
2060
|
+
channel: transport.channel,
|
|
2061
|
+
attempt: 0,
|
|
2062
|
+
kind: e.status,
|
|
2063
|
+
status: e.status,
|
|
2064
|
+
campaignId: logsToCampaign.get(e.providerMessageId) ?? null,
|
|
2065
|
+
metadata: e.metadata ?? null
|
|
2066
|
+
}));
|
|
2067
|
+
const skipped = events.length - rows.length;
|
|
2068
|
+
if (skipped > 0) logger.warn({
|
|
2069
|
+
channel,
|
|
2070
|
+
skipped
|
|
2071
|
+
}, "webhook events skipped: unknown providerMessageId");
|
|
2072
|
+
if (rows.length > 0) await db.insert(messageLogs).values(rows).onConflictDoNothing();
|
|
2073
|
+
const suppressionRows = attributable.filter((e) => e.recipient && (e.status === "unsubscribed" || e.status === "complained" || e.status === "bounced" && e.bounceType === "hard")).map((e) => ({
|
|
2074
|
+
projectId: logsToProject.get(e.providerMessageId),
|
|
2075
|
+
channel: transport.channel,
|
|
2076
|
+
target: normaliseTarget(e.recipient),
|
|
2077
|
+
reason: e.status,
|
|
2078
|
+
source: channel,
|
|
2079
|
+
taskId: logsToTask.get(e.providerMessageId)
|
|
2080
|
+
}));
|
|
2081
|
+
if (suppressionRows.length > 0) {
|
|
2082
|
+
await db.insert(suppressions).values(suppressionRows).onConflictDoNothing();
|
|
2083
|
+
logger.info({
|
|
2084
|
+
channel,
|
|
2085
|
+
count: suppressionRows.length
|
|
2086
|
+
}, "addresses suppressed from provider webhook");
|
|
2087
|
+
}
|
|
2088
|
+
const unsuppressable = attributable.filter((e) => !e.recipient && (e.status === "unsubscribed" || e.status === "complained" || e.status === "bounced")).length;
|
|
2089
|
+
if (unsuppressable > 0) logger.warn({
|
|
2090
|
+
channel,
|
|
2091
|
+
count: unsuppressable
|
|
2092
|
+
}, "suppression events carried no recipient address — transport must set WebhookEvent.recipient");
|
|
2093
|
+
}
|
|
2094
|
+
if (!res.headersSent) sendJson(res, 200, { success: true });
|
|
2095
|
+
})(), new Promise((_, reject) => {
|
|
2096
|
+
deadline = setTimeout(() => reject(/* @__PURE__ */ new Error("Webhook processing timeout")), 15e3);
|
|
2097
|
+
})]);
|
|
2098
|
+
} catch (err) {
|
|
2099
|
+
logger.error({
|
|
2100
|
+
err,
|
|
2101
|
+
channel
|
|
2102
|
+
}, "webhook processing error or timeout");
|
|
2103
|
+
if (!res.headersSent) sendJson(res, 500, { error: "internal_error" });
|
|
2104
|
+
} finally {
|
|
2105
|
+
clearTimeout(deadline);
|
|
2106
|
+
}
|
|
2107
|
+
};
|
|
2108
|
+
}
|
|
2109
|
+
//#endregion
|
|
1817
2110
|
//#region src/services/api/main.ts
|
|
1818
2111
|
/** Pub/sub channel used to drop a cached API key across every API process. */
|
|
1819
2112
|
const API_KEY_INVALIDATION_CHANNEL = "apikey.invalidated";
|
|
@@ -1835,11 +2128,12 @@ let authSubscriber = null;
|
|
|
1835
2128
|
let router;
|
|
1836
2129
|
let liveEvents = null;
|
|
1837
2130
|
let apiRateLimiter;
|
|
1838
|
-
|
|
1839
|
-
|
|
1840
|
-
if (
|
|
1841
|
-
const
|
|
1842
|
-
|
|
2131
|
+
/** Whether `token` is ADMIN_API_KEY, compared in constant time. */
|
|
2132
|
+
function isAdminApiKey(token) {
|
|
2133
|
+
if (!config.ADMIN_API_KEY) return false;
|
|
2134
|
+
const expectedBuffer = Buffer.from(config.ADMIN_API_KEY);
|
|
2135
|
+
const providedBuffer = Buffer.from(token);
|
|
2136
|
+
return expectedBuffer.length === providedBuffer.length && timingSafeEqual(expectedBuffer, providedBuffer);
|
|
1843
2137
|
}
|
|
1844
2138
|
/**
|
|
1845
2139
|
* What a dashboard user's role may do. `admin_users.role` is free text (the
|
|
@@ -1885,107 +2179,6 @@ async function handleCreateProject(req, res) {
|
|
|
1885
2179
|
apiKey
|
|
1886
2180
|
});
|
|
1887
2181
|
}
|
|
1888
|
-
let cachedHealth = null;
|
|
1889
|
-
async function handleHealth(_req, res) {
|
|
1890
|
-
if (cachedHealth && cachedHealth.expiresAt > Date.now()) {
|
|
1891
|
-
sendJson(res, cachedHealth.statusCode, cachedHealth.response);
|
|
1892
|
-
return;
|
|
1893
|
-
}
|
|
1894
|
-
const [redisOk, dbOk] = await Promise.all([redis.healthCheck(), dbHealthCheck()]);
|
|
1895
|
-
const workers = {};
|
|
1896
|
-
let overallOk = redisOk && dbOk;
|
|
1897
|
-
if (redisOk) {
|
|
1898
|
-
const keys = [
|
|
1899
|
-
"enricher",
|
|
1900
|
-
"engine",
|
|
1901
|
-
"scheduler",
|
|
1902
|
-
"delivery",
|
|
1903
|
-
"ai",
|
|
1904
|
-
"workflow",
|
|
1905
|
-
"events"
|
|
1906
|
-
];
|
|
1907
|
-
try {
|
|
1908
|
-
const vals = await redis.native.mget(keys.map((k) => `notif:health:${k}`));
|
|
1909
|
-
for (let i = 0; i < keys.length; i++) {
|
|
1910
|
-
const key = keys[i];
|
|
1911
|
-
const val = vals[i];
|
|
1912
|
-
if (val) {
|
|
1913
|
-
const parsed = JSON.parse(val);
|
|
1914
|
-
workers[key] = parsed;
|
|
1915
|
-
if (parsed.redis === false || parsed.state === "error") overallOk = false;
|
|
1916
|
-
} else workers[key] = {
|
|
1917
|
-
status: "unknown",
|
|
1918
|
-
message: "No report received from worker"
|
|
1919
|
-
};
|
|
1920
|
-
}
|
|
1921
|
-
} catch (err) {
|
|
1922
|
-
for (const key of keys) workers[key] = {
|
|
1923
|
-
status: "error",
|
|
1924
|
-
error: err instanceof Error ? err.message : String(err)
|
|
1925
|
-
};
|
|
1926
|
-
}
|
|
1927
|
-
}
|
|
1928
|
-
const statusCode = overallOk ? 200 : 503;
|
|
1929
|
-
const response = {
|
|
1930
|
-
service: "api",
|
|
1931
|
-
status: overallOk ? "ok" : "degraded",
|
|
1932
|
-
redis: redisOk,
|
|
1933
|
-
database: dbOk,
|
|
1934
|
-
workers
|
|
1935
|
-
};
|
|
1936
|
-
cachedHealth = {
|
|
1937
|
-
response,
|
|
1938
|
-
statusCode,
|
|
1939
|
-
expiresAt: Date.now() + 1e3
|
|
1940
|
-
};
|
|
1941
|
-
sendJson(res, statusCode, response);
|
|
1942
|
-
}
|
|
1943
|
-
async function handleMetrics(req, res) {
|
|
1944
|
-
const remoteIp = req.socket.remoteAddress ?? "";
|
|
1945
|
-
let authorized = remoteIp === "127.0.0.1" || remoteIp === "::1" || remoteIp === "::ffff:127.0.0.1" || remoteIp === "localhost";
|
|
1946
|
-
if (!authorized) {
|
|
1947
|
-
const token = extractAuthToken(req);
|
|
1948
|
-
if (token) {
|
|
1949
|
-
if (token.startsWith("nk_sess_") && redis?.native) {
|
|
1950
|
-
if (await getAdminSession(redis.native, token)) authorized = true;
|
|
1951
|
-
} else if (config.ADMIN_API_KEY) {
|
|
1952
|
-
const expectedBuffer = Buffer.from(config.ADMIN_API_KEY);
|
|
1953
|
-
const providedBuffer = Buffer.from(token);
|
|
1954
|
-
if (expectedBuffer.length === providedBuffer.length && timingSafeEqual(expectedBuffer, providedBuffer)) authorized = true;
|
|
1955
|
-
}
|
|
1956
|
-
}
|
|
1957
|
-
}
|
|
1958
|
-
if (!authorized) {
|
|
1959
|
-
sendJson(res, 401, {
|
|
1960
|
-
error: "unauthorized",
|
|
1961
|
-
message: "Metrics endpoint requires admin credentials"
|
|
1962
|
-
});
|
|
1963
|
-
return;
|
|
1964
|
-
}
|
|
1965
|
-
const registry = getMetricsRegistry();
|
|
1966
|
-
res.writeHead(200, { "Content-Type": registry.contentType });
|
|
1967
|
-
res.end(await registry.metrics());
|
|
1968
|
-
}
|
|
1969
|
-
async function handleLive(_req, res) {
|
|
1970
|
-
sendJson(res, 200, { status: "ok" });
|
|
1971
|
-
}
|
|
1972
|
-
async function handleReady(_req, res) {
|
|
1973
|
-
if (cachedHealth && cachedHealth.expiresAt > Date.now()) {
|
|
1974
|
-
sendJson(res, cachedHealth.statusCode === 200 ? 200 : 503, { status: cachedHealth.statusCode === 200 ? "ready" : "unready" });
|
|
1975
|
-
return;
|
|
1976
|
-
}
|
|
1977
|
-
const [redisOk, dbOk] = await Promise.all([redis.healthCheck(), dbHealthCheck()]);
|
|
1978
|
-
const isReady = redisOk && dbOk;
|
|
1979
|
-
sendJson(res, isReady ? 200 : 503, { status: isReady ? "ready" : "unready" });
|
|
1980
|
-
}
|
|
1981
|
-
async function dbHealthCheck() {
|
|
1982
|
-
try {
|
|
1983
|
-
await sql$1`SELECT 1`;
|
|
1984
|
-
return true;
|
|
1985
|
-
} catch {
|
|
1986
|
-
return false;
|
|
1987
|
-
}
|
|
1988
|
-
}
|
|
1989
2182
|
let server;
|
|
1990
2183
|
async function startApiServer() {
|
|
1991
2184
|
logger = createLogger({
|
|
@@ -2071,6 +2264,11 @@ async function startApiServer() {
|
|
|
2071
2264
|
db
|
|
2072
2265
|
};
|
|
2073
2266
|
h = createHandlers(deps);
|
|
2267
|
+
const { handleHealth, handleMetrics, handleLive, handleReady } = createHealthHandlers({
|
|
2268
|
+
redis,
|
|
2269
|
+
sql: sql$1,
|
|
2270
|
+
isAdminApiKey
|
|
2271
|
+
});
|
|
2074
2272
|
router = new Router();
|
|
2075
2273
|
router.post("/v1/auth/login", h.login).post("/v1/auth/logout", h.logout).get("/v1/auth/me", h.getMe).put("/v1/templates", h.syncTemplates).get("/v1/templates", h.listTemplates).get("/v1/templates/:id", h.getTemplate).delete("/v1/templates/:id", h.deleteTemplate).post("/v1/users", h.addUser).get("/v1/users", h.listUsers).get("/v1/users/:id", h.getUser).get("/v1/users/:id/details", h.getUserDetails).patch("/v1/users/:id", h.updateUser).delete("/v1/users/:id", h.deleteUser).post("/v1/users/:id/contacts", h.addContact).get("/v1/users/:id/contacts", h.getUserContacts).delete("/v1/users/:id/contacts/:channel/:target", h.deleteContact).get("/v1/users/:id/preferences", h.getUserPreferences).patch("/v1/users/:id/preferences", h.updateUserPreferences).post("/v1/notify", h.notify).get("/v1/notifications/scheduled", h.getScheduledMessages).get("/v1/notifications/logs", h.getNotificationLogs).get("/v1/notifications/:taskId", h.getNotificationStatus).delete("/v1/notifications/:taskId", h.cancelNotification).get("/v1/unsubscribe", h.unsubscribePage).post("/v1/unsubscribe", h.unsubscribe).get("/v1/campaigns", h.listCampaigns).get("/v1/campaigns/:campaign/stats", h.getCampaignStats).get("/v1/suppressions", h.listSuppressions).post("/v1/suppressions", h.createSuppression).delete("/v1/suppressions/:channel/:target", h.deleteSuppression).get("/v1/system/health", h.getSystemHealth).get("/v1/system/metrics", h.getSystemMetrics).get("/v1/dlq", h.getDLQMessages).post("/v1/dlq/replay", h.replayDLQMessage).delete("/v1/dlq/:id", h.deleteDLQMessage).post("/v1/workflows", h.createWorkflow).get("/v1/workflows", h.listWorkflows).get("/v1/workflows/instances/:id", h.getWorkflow).delete("/v1/workflows/instances/:id", h.cancelWorkflow).post("/v1/workflows/trigger", h.triggerWorkflow).get("/v1/segments", h.listSegments).post("/v1/events", h.ingestEvent).get("/v1/events/stream", h.getEventsStream).get("/v1/projects", h.listProjects).post("/v1/projects", handleCreateProject).delete("/v1/projects/:id", h.deleteProject).patch("/v1/projects/:id", h.updateProject).post("/v1/projects/:id/keys", h.createProjectKey).get("/v1/projects/:id/keys", h.listProjectKeys).delete("/v1/projects/:id/keys/:keyId", h.deleteProjectKey).get("/health", handleHealth).get("/metrics", handleMetrics).get("/live", handleLive).get("/ready", handleReady);
|
|
2076
2274
|
server = createServer((req, res) => {
|
|
@@ -2130,11 +2328,7 @@ async function startApiServer() {
|
|
|
2130
2328
|
isAdminToken = true;
|
|
2131
2329
|
keyRole = sessionKeyRole(session.role);
|
|
2132
2330
|
}
|
|
2133
|
-
} else if (
|
|
2134
|
-
const expectedBuffer = Buffer.from(config.ADMIN_API_KEY);
|
|
2135
|
-
const providedBuffer = Buffer.from(token);
|
|
2136
|
-
if (expectedBuffer.length === providedBuffer.length && timingSafeEqual(expectedBuffer, providedBuffer)) isAdminToken = true;
|
|
2137
|
-
}
|
|
2331
|
+
} else if (isAdminApiKey(token)) isAdminToken = true;
|
|
2138
2332
|
if (isAdminToken) {
|
|
2139
2333
|
const headerProjectId = req.headers["x-project-id"] || searchParams().get("projectId") || void 0;
|
|
2140
2334
|
const isProjectAgnostic = pathname.startsWith("/v1/auth/") || pathname.startsWith("/v1/system/") || pathname.startsWith("/v1/dlq");
|
|
@@ -2179,7 +2373,10 @@ async function startApiServer() {
|
|
|
2179
2373
|
tokenHash
|
|
2180
2374
|
});
|
|
2181
2375
|
tokenHashToToken.set(tokenHash, token);
|
|
2182
|
-
if (tokenHashToToken.size > 2e3)
|
|
2376
|
+
if (tokenHashToToken.size > 2e3) {
|
|
2377
|
+
tokenHashToToken.clear();
|
|
2378
|
+
authCache.clear();
|
|
2379
|
+
}
|
|
2183
2380
|
}
|
|
2184
2381
|
}
|
|
2185
2382
|
if (keyRole === "read_only") {
|
|
@@ -2191,11 +2388,6 @@ async function startApiServer() {
|
|
|
2191
2388
|
return;
|
|
2192
2389
|
}
|
|
2193
2390
|
}
|
|
2194
|
-
if (!apiRateLimiter && redis?.native) apiRateLimiter = new ApiRateLimiter({
|
|
2195
|
-
redis: redis.native,
|
|
2196
|
-
windowMs: API_RATE_LIMIT_WINDOW_MS,
|
|
2197
|
-
logger
|
|
2198
|
-
});
|
|
2199
2391
|
if (!(apiRateLimiter ? await apiRateLimiter.check(projectId || "global", projectRateLimitRpm) : true)) {
|
|
2200
2392
|
if (!res.headersSent) {
|
|
2201
2393
|
res.setHeader("Retry-After", "60");
|
|
@@ -2228,11 +2420,7 @@ async function startApiServer() {
|
|
|
2228
2420
|
}
|
|
2229
2421
|
authorized = true;
|
|
2230
2422
|
}
|
|
2231
|
-
} else if (
|
|
2232
|
-
const expectedBuffer = Buffer.from(config.ADMIN_API_KEY);
|
|
2233
|
-
const providedBuffer = Buffer.from(token);
|
|
2234
|
-
if (expectedBuffer.length === providedBuffer.length && timingSafeEqual(expectedBuffer, providedBuffer)) authorized = true;
|
|
2235
|
-
}
|
|
2423
|
+
} else if (isAdminApiKey(token)) authorized = true;
|
|
2236
2424
|
if (!authorized) {
|
|
2237
2425
|
sendJson(res, 401, {
|
|
2238
2426
|
error: "unauthorized",
|
|
@@ -2344,103 +2532,10 @@ async function startApiServer() {
|
|
|
2344
2532
|
logger.info(`Mounted webhook verification GET for ${channel} at ${transport.webhookPath}`);
|
|
2345
2533
|
}
|
|
2346
2534
|
if (transport.parseWebhook) {
|
|
2347
|
-
router.post(transport.webhookPath,
|
|
2348
|
-
|
|
2349
|
-
|
|
2350
|
-
|
|
2351
|
-
const rawBody = await readRawBody(req);
|
|
2352
|
-
if (!transport.verifyWebhook) {
|
|
2353
|
-
if (!res.headersSent) sendJson(res, 501, {
|
|
2354
|
-
error: "not_implemented",
|
|
2355
|
-
message: "Webhook signature verification is not implemented for this provider"
|
|
2356
|
-
});
|
|
2357
|
-
return;
|
|
2358
|
-
}
|
|
2359
|
-
if (!await transport.verifyWebhook(rawBody, req.headers)) {
|
|
2360
|
-
if (!res.headersSent) sendJson(res, 401, {
|
|
2361
|
-
error: "unauthorized",
|
|
2362
|
-
message: "Invalid webhook signature"
|
|
2363
|
-
});
|
|
2364
|
-
return;
|
|
2365
|
-
}
|
|
2366
|
-
let body;
|
|
2367
|
-
try {
|
|
2368
|
-
body = rawBody ? JSON.parse(rawBody) : {};
|
|
2369
|
-
} catch {
|
|
2370
|
-
body = {};
|
|
2371
|
-
}
|
|
2372
|
-
const events = await transport.parseWebhook(body, rawBody, req.headers);
|
|
2373
|
-
if (events.length > 0) {
|
|
2374
|
-
const providerIds = events.map((e) => e.providerMessageId).filter(Boolean);
|
|
2375
|
-
const logsToProject = /* @__PURE__ */ new Map();
|
|
2376
|
-
const logsToTask = /* @__PURE__ */ new Map();
|
|
2377
|
-
const logsToCampaign = /* @__PURE__ */ new Map();
|
|
2378
|
-
if (providerIds.length > 0) {
|
|
2379
|
-
const existing = await db.select({
|
|
2380
|
-
providerMessageId: messageLogs.providerMessageId,
|
|
2381
|
-
projectId: messageLogs.projectId,
|
|
2382
|
-
taskId: messageLogs.taskId,
|
|
2383
|
-
campaignId: messageLogs.campaignId
|
|
2384
|
-
}).from(messageLogs).where(inArray(messageLogs.providerMessageId, providerIds));
|
|
2385
|
-
for (const row of existing) if (row.providerMessageId) {
|
|
2386
|
-
logsToProject.set(row.providerMessageId, row.projectId);
|
|
2387
|
-
logsToTask.set(row.providerMessageId, row.taskId);
|
|
2388
|
-
logsToCampaign.set(row.providerMessageId, row.campaignId);
|
|
2389
|
-
}
|
|
2390
|
-
}
|
|
2391
|
-
const attributable = events.filter((e) => e.providerMessageId && logsToProject.has(e.providerMessageId));
|
|
2392
|
-
const rows = attributable.map((e) => ({
|
|
2393
|
-
projectId: logsToProject.get(e.providerMessageId),
|
|
2394
|
-
taskId: logsToTask.get(e.providerMessageId),
|
|
2395
|
-
providerMessageId: e.providerMessageId,
|
|
2396
|
-
channel: transport.channel,
|
|
2397
|
-
attempt: 0,
|
|
2398
|
-
kind: e.status,
|
|
2399
|
-
status: e.status,
|
|
2400
|
-
campaignId: logsToCampaign.get(e.providerMessageId) ?? null,
|
|
2401
|
-
metadata: e.metadata ?? null
|
|
2402
|
-
}));
|
|
2403
|
-
const skipped = events.length - rows.length;
|
|
2404
|
-
if (skipped > 0) logger.warn({
|
|
2405
|
-
channel,
|
|
2406
|
-
skipped
|
|
2407
|
-
}, "webhook events skipped: unknown providerMessageId");
|
|
2408
|
-
if (rows.length > 0) await db.insert(messageLogs).values(rows).onConflictDoNothing();
|
|
2409
|
-
const suppressionRows = attributable.filter((e) => e.recipient && (e.status === "unsubscribed" || e.status === "complained" || e.status === "bounced" && e.bounceType === "hard")).map((e) => ({
|
|
2410
|
-
projectId: logsToProject.get(e.providerMessageId),
|
|
2411
|
-
channel: transport.channel,
|
|
2412
|
-
target: normaliseTarget(e.recipient),
|
|
2413
|
-
reason: e.status,
|
|
2414
|
-
source: channel,
|
|
2415
|
-
taskId: logsToTask.get(e.providerMessageId)
|
|
2416
|
-
}));
|
|
2417
|
-
if (suppressionRows.length > 0) {
|
|
2418
|
-
await db.insert(suppressions).values(suppressionRows).onConflictDoNothing();
|
|
2419
|
-
logger.info({
|
|
2420
|
-
channel,
|
|
2421
|
-
count: suppressionRows.length
|
|
2422
|
-
}, "addresses suppressed from provider webhook");
|
|
2423
|
-
}
|
|
2424
|
-
const unsuppressable = attributable.filter((e) => !e.recipient && (e.status === "unsubscribed" || e.status === "complained" || e.status === "bounced")).length;
|
|
2425
|
-
if (unsuppressable > 0) logger.warn({
|
|
2426
|
-
channel,
|
|
2427
|
-
count: unsuppressable
|
|
2428
|
-
}, "suppression events carried no recipient address — transport must set WebhookEvent.recipient");
|
|
2429
|
-
}
|
|
2430
|
-
if (!res.headersSent) sendJson(res, 200, { success: true });
|
|
2431
|
-
})(), new Promise((_, reject) => {
|
|
2432
|
-
deadline = setTimeout(() => reject(/* @__PURE__ */ new Error("Webhook processing timeout")), 15e3);
|
|
2433
|
-
})]);
|
|
2434
|
-
} catch (err) {
|
|
2435
|
-
logger.error({
|
|
2436
|
-
err,
|
|
2437
|
-
channel
|
|
2438
|
-
}, "webhook processing error or timeout");
|
|
2439
|
-
if (!res.headersSent) sendJson(res, 500, { error: "internal_error" });
|
|
2440
|
-
} finally {
|
|
2441
|
-
clearTimeout(deadline);
|
|
2442
|
-
}
|
|
2443
|
-
});
|
|
2535
|
+
router.post(transport.webhookPath, createWebhookHandler(transport, channel, {
|
|
2536
|
+
db,
|
|
2537
|
+
logger
|
|
2538
|
+
}));
|
|
2444
2539
|
logger.info(`Mounted webhook for ${channel} at ${transport.webhookPath}`);
|
|
2445
2540
|
}
|
|
2446
2541
|
}
|
|
@@ -2469,7 +2564,6 @@ async function stopApiServer() {
|
|
|
2469
2564
|
liveEvents = null;
|
|
2470
2565
|
authCache = new LRUCache(1e3, AUTH_CACHE_TTL_MS);
|
|
2471
2566
|
tokenHashToToken.clear();
|
|
2472
|
-
cachedHealth = null;
|
|
2473
2567
|
if (sql$1) await sql$1.end();
|
|
2474
2568
|
if (redis) await redis.disconnect();
|
|
2475
2569
|
logger?.info("api stopped");
|