notifkit 0.1.15 → 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.
Files changed (85) hide show
  1. package/dashboard/dist/assets/index-C-DJYu0_.css +1 -0
  2. package/dashboard/dist/assets/index-CzFZcEon.js +318 -0
  3. package/dashboard/dist/index.html +2 -2
  4. package/dist/{bootstrap-BOmT69OH.mjs → bootstrap-BMDRPjgp.mjs} +1 -1
  5. package/dist/{bulk-ZPiOJRx-.mjs → bulk-CJ5QXiPa.mjs} +1 -1
  6. package/dist/index.d.mts +71 -27
  7. package/dist/index.mjs +2 -2
  8. package/dist/{main-CCqcFDDe.mjs → main-6_bXQBDH.mjs} +21 -41
  9. package/dist/{main-BdZvBgV7.mjs → main-8nP3qmCT.mjs} +22 -48
  10. package/dist/{main-C0m9-Eos.mjs → main-B82bsFoy.mjs} +183 -334
  11. package/dist/{main-CTjaZ7ZD.mjs → main-CpaHF1Zw.mjs} +13 -15
  12. package/dist/{main-JEXBLP2A.mjs → main-DULD8-th.mjs} +8 -6
  13. package/dist/{main-C6S3EsJ3.mjs → main-ZW5RaiOK.mjs} +77 -64
  14. package/dist/{main-g33jpia4.mjs → main-g1KEcXXp.mjs} +676 -582
  15. package/dist/{main-24J4U8yP.mjs → main-mGIT8jv4.mjs} +4 -4
  16. package/dist/schedule-or-dispatch-Cd7GLfc3.mjs +52 -0
  17. package/dist/{src-9LXITcNi.mjs → src-BE_EUpZ6.mjs} +93 -93
  18. package/package.json +1 -1
  19. package/scripts/create-project.mjs +6 -2
  20. package/src/client.ts +3 -3
  21. package/src/config/index.ts +1 -0
  22. package/src/contracts/common.ts +2 -0
  23. package/src/contracts/envelope.ts +1 -1
  24. package/src/contracts/events/notification-created.ts +2 -0
  25. package/src/contracts/events/notification-delivered.ts +1 -1
  26. package/src/contracts/events/notification-failed.ts +1 -1
  27. package/src/contracts/events/notification-requested.ts +3 -2
  28. package/src/contracts/helpers.ts +1 -2
  29. package/src/contracts/index.ts +1 -0
  30. package/src/contracts/registry.ts +1 -0
  31. package/src/contracts/sdk.ts +8 -37
  32. package/src/db/schema.ts +8 -13
  33. package/src/idempotency/index.ts +6 -8
  34. package/src/metrics/index.ts +2 -0
  35. package/src/rate-limiter/api-rate-limiter.ts +208 -0
  36. package/src/rate-limiter/index.ts +3 -411
  37. package/src/rate-limiter/project-settings-cache.ts +99 -0
  38. package/src/rate-limiter/user-throttle.ts +100 -0
  39. package/src/redis/index.ts +10 -3
  40. package/src/repositories/admin-user.ts +83 -0
  41. package/src/repositories/contact.ts +359 -0
  42. package/src/repositories/index.ts +9 -1416
  43. package/src/repositories/preference.ts +35 -0
  44. package/src/repositories/project.ts +110 -0
  45. package/src/repositories/segment.ts +16 -0
  46. package/src/repositories/template.ts +72 -0
  47. package/src/repositories/types.ts +49 -0
  48. package/src/repositories/user.ts +644 -0
  49. package/src/repositories/workflow.ts +64 -0
  50. package/src/services/ai/main.ts +29 -71
  51. package/src/services/api/admin-static.ts +4 -1
  52. package/src/services/api/handlers/auth.ts +109 -0
  53. package/src/services/api/handlers/campaigns.ts +191 -0
  54. package/src/services/api/handlers/events.ts +99 -0
  55. package/src/services/api/handlers/notifications.ts +356 -0
  56. package/src/services/api/handlers/projects.ts +116 -0
  57. package/src/services/api/handlers/shared.ts +262 -0
  58. package/src/services/api/handlers/suppressions.ts +95 -0
  59. package/src/services/api/handlers/system.ts +314 -0
  60. package/src/services/api/handlers/templates.ts +97 -0
  61. package/src/services/api/handlers/unsubscribe.ts +215 -0
  62. package/src/services/api/handlers/users.ts +262 -0
  63. package/src/services/api/handlers/workflows.ts +150 -0
  64. package/src/services/api/handlers.ts +25 -2190
  65. package/src/services/api/health.ts +133 -0
  66. package/src/services/api/http.ts +12 -0
  67. package/src/services/api/main.ts +32 -322
  68. package/src/services/api/router.ts +1 -1
  69. package/src/services/api/webhooks.ts +172 -0
  70. package/src/services/delivery/main.ts +256 -498
  71. package/src/services/engine/main.ts +31 -247
  72. package/src/services/engine/quiet-hours.ts +151 -0
  73. package/src/services/engine/schedule-or-dispatch.ts +104 -0
  74. package/src/services/enricher/main.ts +9 -21
  75. package/src/services/events/main.ts +2 -2
  76. package/src/services/scheduler/main.ts +16 -25
  77. package/src/services/workflow/duration.ts +24 -0
  78. package/src/services/workflow/main.ts +6 -164
  79. package/src/services/workflow/timers.ts +157 -0
  80. package/src/shared/events.ts +3 -2
  81. package/src/templates/render.ts +1 -0
  82. package/src/workers/index.ts +7 -4
  83. package/src/workflows/sdk.ts +1 -0
  84. package/dashboard/dist/assets/index-ggpJKZqZ.js +0 -315
  85. package/dashboard/dist/assets/index-s-SXGIwv.css +0 -1
@@ -1,4 +1,4 @@
1
- import { $ as createDatabase, $t as PUBSUB_CHANNELS, Bt as SyncTemplatesSchema, C as ContactRepository, D as TemplateRepository, Dn as normaliseTarget, E as SegmentRepository, En as getPriorityBucket, Ht as TriggerWorkflowSchema, J as getMetricsRegistry, Jt as buildStreamEvent, Lt as NotifyRequestSchema, Mt as BatchAddContactsSchema, Nt as ContactChannelSchema, O as UserRepository, On as LRUCache, Pt as CreateWorkflowSchema, Rt as PreferencesSchema, S as AdminUserRepository, T as ProjectRepository, V as ApiRateLimiter, Wt as UpdateUserSchema, X as createLogger, Y as metrics, Yt as CONSUMER_GROUPS, at as messageLogs, ct as scheduledPayloads, dt as users, en as STREAMS, ft as workflowDefinitions, g as transportRegistry, hn as readBaseConfig, it as deliveryOutbox, jt as AddUserSchema, k as WorkflowRepository, kn as globalEmitter, lt as suppressions, m as verifyUnsubscribeToken, ot as projectApiKeys, pn as loadEnv, q as StreamProducer, st as projects, ut as userTopicPreferences, z as RedisClient } from "./src-9LXITcNi.mjs";
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 all ~35 registered routes on every request.
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/auth/index.ts
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
- const txUserRepo = deps.userRepo.constructor.name === "Object" ? deps.userRepo : new deps.userRepo.constructor(tx);
297
- const txContactRepo = deps.contactRepo.constructor.name === "Object" ? deps.contactRepo : new deps.contactRepo.constructor(tx);
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
- function createHandlers(deps) {
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("template.invalidated", `${ctx.projectId}:${t.id}`);
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 getUser(req, res, ctx) {
783
- const userId = ctx.params.id;
784
- const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
785
- if (!user) return sendJson(res, 404, {
786
- error: "user_not_found",
787
- id: userId
788
- });
789
- const contacts = await deps.contactRepo.findByUserId(ctx.projectId, userId);
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
- ...user,
792
- contacts
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
- async function updateUserPreferences(req, res, ctx) {
805
- const userId = ctx.params.id;
806
- const parsed = PreferencesSchema.safeParse(await readJsonBody(req));
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
- if (!await deps.userRepo.updatePartial(ctx.projectId, userId, { preferences: parsed.data })) return sendJson(res, 404, {
809
- error: "user_not_found",
810
- id: userId
811
- });
812
- logger.info({ userId }, "user preferences updated");
813
- sendJson(res, 200, {
814
- id: userId,
815
- preferences: parsed.data
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
- async function listUsers(req, res, ctx) {
894
- const limit = parseLimit(ctx, 50);
895
- const cursor = getQueryParam(ctx, "cursor");
896
- const search = getQueryParam(ctx, "search");
897
- const segment = getQueryParam(ctx, "segment");
898
- const language = getQueryParam(ctx, "language");
899
- const timezone = getQueryParam(ctx, "timezone");
900
- const channel = getQueryParam(ctx, "channel");
901
- const filters = search || segment || language || timezone || channel ? {
902
- search,
903
- segment,
904
- language,
905
- timezone,
906
- channel
907
- } : void 0;
908
- sendJson(res, 200, await deps.userRepo.list(ctx.projectId, limit, cursor, filters));
909
- }
910
- async function getUserContacts(req, res, ctx) {
911
- const userId = ctx.params.id;
912
- sendJson(res, 200, { contacts: await deps.contactRepo.findByUserId(ctx.projectId, userId) });
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 listSegments(req, res, ctx) {
915
- sendJson(res, 200, { segments: await deps.segmentRepo.listSegments(ctx.projectId) });
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 = z.object({
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("apikey.invalidated", "*");
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).catch(() => ({})))?.id;
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
- async function getScheduledMessages(_req, res, ctx) {
1190
- const limit = parseLimit(ctx, 50);
1191
- const cursor = getQueryParam(ctx, "cursor");
1192
- const channel = getQueryParam(ctx, "channel");
1193
- const conditions = [sql`(payload->>'projectId') = ${ctx.projectId}`];
1194
- if (cursor) conditions.push(sql`task_id > ${cursor}`);
1195
- if (channel) conditions.push(sql`(payload->>'channel') = ${channel}`);
1196
- const rows = await deps.db.select().from(scheduledPayloads).where(and(...conditions)).orderBy(scheduledPayloads.taskId).limit(limit + 1);
1197
- const hasNext = rows.length > limit;
1198
- const scheduled = hasNext ? rows.slice(0, limit) : rows;
1199
- sendJson(res, 200, {
1200
- scheduled,
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
- syncTemplates,
1535
- addUser,
1536
- updateUser,
1537
- deleteUser,
1538
- addContact,
1539
- deleteContact,
1540
- notify,
1541
- cancelNotification,
1542
- triggerWorkflow,
1543
- ingestEvent,
1544
- getEventsStream,
1545
- getNotificationLogs,
1546
- getNotificationStatus,
1547
- getUser,
1548
- getUserDetails,
1549
- unsubscribePage,
1550
- unsubscribe,
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
- function extractAuthToken(req) {
1839
- const authHeader = req.headers["authorization"];
1840
- if (typeof authHeader === "string" && authHeader.toLowerCase().startsWith("bearer ")) return authHeader.slice(7).trim();
1841
- const apiKeyHeader = req.headers["x-api-key"];
1842
- if (typeof apiKeyHeader === "string") return apiKeyHeader.trim();
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 (config.ADMIN_API_KEY) {
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) tokenHashToToken.clear();
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 (config.ADMIN_API_KEY) {
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, async (req, res) => {
2348
- let deadline;
2349
- try {
2350
- await Promise.race([(async () => {
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");