@terreno/comms 57.0.0 → 57.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -46,18 +46,59 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
46
46
  if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
47
47
  }
48
48
  };
49
+ var __read = (this && this.__read) || function (o, n) {
50
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
51
+ if (!m) return o;
52
+ var i = m.call(o), r, ar = [], e;
53
+ try {
54
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
55
+ }
56
+ catch (error) { e = { error: error }; }
57
+ finally {
58
+ try {
59
+ if (r && !r.done && (m = i["return"])) m.call(i);
60
+ }
61
+ finally { if (e) throw e.error; }
62
+ }
63
+ return ar;
64
+ };
65
+ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
66
+ if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
67
+ if (ar || !(i in from)) {
68
+ if (!ar) ar = Array.prototype.slice.call(from, 0, i);
69
+ ar[i] = from[i];
70
+ }
71
+ }
72
+ return to.concat(ar || Array.prototype.slice.call(from));
73
+ };
49
74
  Object.defineProperty(exports, "__esModule", { value: true });
50
75
  exports.CommsService = void 0;
51
76
  var api_1 = require("@terreno/api");
77
+ var luxon_1 = require("luxon");
52
78
  var console_1 = require("./adapters/console");
53
79
  var commsMessage_1 = require("./models/commsMessage");
54
80
  var pushToken_1 = require("./models/pushToken");
55
81
  var CHANNEL_NOT_CONFIGURED_TITLE = "Comms channel not configured";
56
82
  var REDACTED_RECIPIENT = "[redacted]";
83
+ var DEFAULT_RETAIN_PAYLOAD_DAYS = 30;
84
+ var CANCELLED_ERROR = "Cancelled by beforeSend";
85
+ var HOOK_THREW = "hook-threw";
57
86
  var throwUnconfiguredChannel = function () {
58
87
  throw new api_1.APIError({ status: 501, title: CHANNEL_NOT_CONFIGURED_TITLE });
59
88
  };
60
89
  var isProduction = function () { return process.env.NODE_ENV === "production"; };
90
+ var providerThrowResult = function (error) { return ({
91
+ accepted: false,
92
+ error: error instanceof Error ? error.message : "Provider send failed",
93
+ errorClass: "transient",
94
+ errorCode: "provider-throw",
95
+ }); };
96
+ var isTransientFailure = function (result) {
97
+ return !result.accepted && result.errorClass === "transient";
98
+ };
99
+ var isPermanentPushFailure = function (result) {
100
+ return result.isPermanentFailure === true || result.errorClass === "permanent";
101
+ };
61
102
  var CommsService = /** @class */ (function () {
62
103
  function CommsService(options) {
63
104
  this.consoleMail = new console_1.ConsoleMailProvider();
@@ -66,35 +107,490 @@ var CommsService = /** @class */ (function () {
66
107
  this.consoleVerification = new console_1.ConsoleVerificationProvider();
67
108
  this.options = options !== null && options !== void 0 ? options : {};
68
109
  }
110
+ CommsService.prototype.recordDeliveryEvent = function (event) {
111
+ return __awaiter(this, void 0, void 0, function () {
112
+ var onDeliveryEvent, row, error_1;
113
+ return __generator(this, function (_a) {
114
+ switch (_a.label) {
115
+ case 0:
116
+ onDeliveryEvent = this.options.onDeliveryEvent;
117
+ return [4 /*yield*/, this.invokeHook(onDeliveryEvent ? function () { return onDeliveryEvent(event); } : undefined, "onDeliveryEvent")];
118
+ case 1:
119
+ _a.sent();
120
+ if (this.options.logMessages === false || !event.providerMessageId) {
121
+ return [2 /*return*/];
122
+ }
123
+ _a.label = 2;
124
+ case 2:
125
+ _a.trys.push([2, 5, , 6]);
126
+ return [4 /*yield*/, commsMessage_1.CommsMessage.findOneOrNone({ providerMessageId: event.providerMessageId })];
127
+ case 3:
128
+ row = _a.sent();
129
+ if (!row) {
130
+ api_1.logger.warn("[comms] No CommsMessage for delivery event ".concat(event.providerMessageId));
131
+ return [2 /*return*/];
132
+ }
133
+ if (event.status === "opened") {
134
+ return [2 /*return*/];
135
+ }
136
+ row.status = event.status;
137
+ if (event.errorClass) {
138
+ row.errorClass = event.errorClass;
139
+ }
140
+ if (event.errorCode) {
141
+ row.errorCode = event.errorCode;
142
+ }
143
+ return [4 /*yield*/, row.save()];
144
+ case 4:
145
+ _a.sent();
146
+ return [3 /*break*/, 6];
147
+ case 5:
148
+ error_1 = _a.sent();
149
+ api_1.logger.warn("[comms] Failed to apply delivery event: ".concat(String(error_1)));
150
+ return [3 /*break*/, 6];
151
+ case 6: return [2 /*return*/];
152
+ }
153
+ });
154
+ });
155
+ };
156
+ CommsService.prototype.recordOptOut = function (event) {
157
+ return __awaiter(this, void 0, void 0, function () {
158
+ var onOptOut;
159
+ return __generator(this, function (_a) {
160
+ switch (_a.label) {
161
+ case 0:
162
+ onOptOut = this.options.onOptOut;
163
+ return [4 /*yield*/, this.invokeHook(onOptOut ? function () { return onOptOut(event); } : undefined, "onOptOut")];
164
+ case 1:
165
+ _a.sent();
166
+ return [2 /*return*/];
167
+ }
168
+ });
169
+ });
170
+ };
171
+ CommsService.prototype.clearExpiredPayloads = function () {
172
+ return __awaiter(this, void 0, void 0, function () {
173
+ return __generator(this, function (_a) {
174
+ return [2 /*return*/, commsMessage_1.CommsMessage.clearExpiredPayloads()];
175
+ });
176
+ });
177
+ };
69
178
  CommsService.prototype.recipientForLog = function (recipient) {
70
179
  if (this.options.redactRecipients !== false) {
71
180
  return REDACTED_RECIPIENT;
72
181
  }
73
182
  return Array.isArray(recipient) ? recipient.join(",") : recipient;
74
183
  };
184
+ CommsService.prototype.retainPayloadDays = function () {
185
+ var _a;
186
+ return (_a = this.options.retainPayloadDays) !== null && _a !== void 0 ? _a : DEFAULT_RETAIN_PAYLOAD_DAYS;
187
+ };
188
+ CommsService.prototype.invokeHook = function (hook, label) {
189
+ return __awaiter(this, void 0, void 0, function () {
190
+ var error_2, message;
191
+ return __generator(this, function (_a) {
192
+ switch (_a.label) {
193
+ case 0:
194
+ if (!hook) {
195
+ return [2 /*return*/, undefined];
196
+ }
197
+ _a.label = 1;
198
+ case 1:
199
+ _a.trys.push([1, 3, , 4]);
200
+ return [4 /*yield*/, hook()];
201
+ case 2:
202
+ _a.sent();
203
+ return [2 /*return*/, undefined];
204
+ case 3:
205
+ error_2 = _a.sent();
206
+ message = "[comms] ".concat(label, " hook failed: ").concat(String(error_2));
207
+ api_1.logger.error(message);
208
+ return [2 /*return*/, HOOK_THREW];
209
+ case 4: return [2 /*return*/];
210
+ }
211
+ });
212
+ });
213
+ };
214
+ CommsService.prototype.appendHookError = function (hookErrors, label, error) {
215
+ var _a;
216
+ if (!error) {
217
+ return;
218
+ }
219
+ var existing = (_a = hookErrors[label]) !== null && _a !== void 0 ? _a : [];
220
+ existing.push(error);
221
+ hookErrors[label] = existing;
222
+ };
223
+ CommsService.prototype.applyBeforeSend = function (context, hookErrors) {
224
+ return __awaiter(this, void 0, void 0, function () {
225
+ var beforeSend, result, error_3;
226
+ var _a;
227
+ return __generator(this, function (_b) {
228
+ switch (_b.label) {
229
+ case 0:
230
+ beforeSend = this.options.beforeSend;
231
+ if (!beforeSend) {
232
+ return [2 /*return*/, { cancel: false, message: context.message }];
233
+ }
234
+ _b.label = 1;
235
+ case 1:
236
+ _b.trys.push([1, 3, , 4]);
237
+ return [4 /*yield*/, beforeSend(context)];
238
+ case 2:
239
+ result = _b.sent();
240
+ if (!result) {
241
+ return [2 /*return*/, { cancel: false, message: context.message }];
242
+ }
243
+ return [2 /*return*/, {
244
+ cancel: result.cancel === true,
245
+ message: (_a = result.message) !== null && _a !== void 0 ? _a : context.message,
246
+ }];
247
+ case 3:
248
+ error_3 = _b.sent();
249
+ this.appendHookError(hookErrors, "beforeSend", HOOK_THREW);
250
+ api_1.logger.error("[comms] beforeSend hook failed: ".concat(String(error_3)));
251
+ return [2 /*return*/, { cancel: false, message: context.message }];
252
+ case 4: return [2 /*return*/];
253
+ }
254
+ });
255
+ });
256
+ };
257
+ CommsService.prototype.defaultPayload = function (message, channel) {
258
+ if (channel === "mail") {
259
+ var mail = message;
260
+ return {
261
+ dynamicTemplateData: mail.dynamicTemplateData,
262
+ from: mail.from,
263
+ html: mail.html,
264
+ replyTo: mail.replyTo,
265
+ subject: mail.subject,
266
+ templateId: mail.templateId,
267
+ text: mail.text,
268
+ to: mail.to,
269
+ };
270
+ }
271
+ if (channel === "sms") {
272
+ var sms = message;
273
+ return { body: sms.body, to: sms.to };
274
+ }
275
+ if (channel === "push") {
276
+ var push = message;
277
+ return {
278
+ badge: push.badge,
279
+ body: push.body,
280
+ data: push.data,
281
+ sound: push.sound,
282
+ title: push.title,
283
+ };
284
+ }
285
+ return { channel: message.channel };
286
+ };
287
+ CommsService.prototype.resolvePayload = function (context, hookErrors) {
288
+ if (this.retainPayloadDays() <= 0) {
289
+ return undefined;
290
+ }
291
+ var payload = this.defaultPayload(context.message, context.channel);
292
+ var redactPayload = this.options.redactPayload;
293
+ if (!redactPayload) {
294
+ return payload;
295
+ }
296
+ try {
297
+ return redactPayload(context, payload);
298
+ }
299
+ catch (error) {
300
+ this.appendHookError(hookErrors, "redactPayload", HOOK_THREW);
301
+ api_1.logger.error("[comms] redactPayload hook failed: ".concat(String(error)));
302
+ return undefined;
303
+ }
304
+ };
305
+ CommsService.prototype.payloadExpiresAt = function () {
306
+ var days = this.retainPayloadDays();
307
+ if (days <= 0) {
308
+ return undefined;
309
+ }
310
+ return luxon_1.DateTime.utc().plus({ days: days }).toJSDate();
311
+ };
312
+ CommsService.prototype.cloneHookErrors = function (hookErrors) {
313
+ return Object.fromEntries(Object.entries(hookErrors).map(function (_a) {
314
+ var _b = __read(_a, 2), key = _b[0], values = _b[1];
315
+ return [key, __spreadArray([], __read(values), false)];
316
+ }));
317
+ };
318
+ CommsService.prototype.cloneContext = function (context, overrides) {
319
+ if (overrides === void 0) { overrides = {}; }
320
+ return __assign(__assign({}, context), overrides);
321
+ };
322
+ CommsService.prototype.resultsByToken = function (tokens, results) {
323
+ var missingResult = {
324
+ accepted: false,
325
+ error: "Provider returned no result for token",
326
+ };
327
+ return new Map(tokens.map(function (token, index) { var _a; return [token, (_a = results[index]) !== null && _a !== void 0 ? _a : missingResult]; }));
328
+ };
329
+ CommsService.prototype.attemptFromResult = function (provider, result) {
330
+ return {
331
+ at: luxon_1.DateTime.utc().toJSDate(),
332
+ error: result.error,
333
+ errorClass: result.errorClass,
334
+ errorCode: result.errorCode,
335
+ provider: provider,
336
+ providerMessageId: result.providerMessageId,
337
+ };
338
+ };
75
339
  CommsService.prototype.logResult = function (_a) {
76
340
  return __awaiter(this, arguments, void 0, function (_b) {
77
- var channel = _b.channel, metadata = _b.metadata, provider = _b.provider, result = _b.result, subject = _b.subject, to = _b.to, userId = _b.userId;
341
+ var payload, lastAttempt, mergedMetadata, logged;
342
+ var attempts = _b.attempts, channel = _b.channel, context = _b.context, hookErrors = _b.hookErrors, metadata = _b.metadata, omitPayload = _b.omitPayload, provider = _b.provider, result = _b.result, status = _b.status, subject = _b.subject, templateId = _b.templateId, to = _b.to, userId = _b.userId;
78
343
  return __generator(this, function (_c) {
79
344
  switch (_c.label) {
80
345
  case 0:
81
346
  if (this.options.logMessages === false) {
82
- return [2 /*return*/];
347
+ return [2 /*return*/, null];
83
348
  }
349
+ payload = omitPayload ? undefined : this.resolvePayload(context, hookErrors);
350
+ lastAttempt = attempts[attempts.length - 1];
351
+ mergedMetadata = __assign(__assign(__assign({}, result.metadata), metadata), (Object.keys(hookErrors).length > 0 ? { hookErrors: hookErrors } : {}));
84
352
  return [4 /*yield*/, commsMessage_1.CommsMessage.logSend({
353
+ attemptCount: attempts.length,
354
+ attempts: attempts,
85
355
  channel: channel,
86
356
  error: result.error,
87
- metadata: metadata,
357
+ errorClass: result.errorClass,
358
+ errorCode: result.errorCode,
359
+ lastAttemptAt: lastAttempt === null || lastAttempt === void 0 ? void 0 : lastAttempt.at,
360
+ metadata: mergedMetadata,
361
+ payload: payload,
362
+ payloadExpiresAt: payload === undefined ? undefined : this.payloadExpiresAt(),
88
363
  provider: provider,
89
364
  providerMessageId: result.providerMessageId,
90
- status: result.accepted ? "sent" : "failed",
365
+ status: status,
91
366
  subject: subject,
367
+ templateId: templateId,
92
368
  to: this.recipientForLog(to),
93
369
  userId: userId,
94
370
  })];
95
371
  case 1:
96
- _c.sent();
372
+ logged = _c.sent();
373
+ if (logged) {
374
+ context.messageId = String(logged._id);
375
+ }
376
+ return [2 /*return*/, logged];
377
+ }
378
+ });
379
+ });
380
+ };
381
+ CommsService.prototype.patchHookErrors = function (logged, hookErrors) {
382
+ return __awaiter(this, void 0, void 0, function () {
383
+ return __generator(this, function (_a) {
384
+ switch (_a.label) {
385
+ case 0:
386
+ if (!logged || Object.keys(hookErrors).length === 0) {
387
+ return [2 /*return*/];
388
+ }
389
+ logged.metadata = __assign(__assign({}, logged.metadata), { hookErrors: hookErrors });
390
+ logged.markModified("metadata");
391
+ return [4 /*yield*/, logged.save().catch(function (error) {
392
+ api_1.logger.warn("[comms] Failed to record hook errors: ".concat(String(error)));
393
+ })];
394
+ case 1:
395
+ _a.sent();
396
+ return [2 /*return*/];
397
+ }
398
+ });
399
+ });
400
+ };
401
+ CommsService.prototype.notifyOutcomeHooks = function (context, result, hookErrors) {
402
+ return __awaiter(this, void 0, void 0, function () {
403
+ var onSend_1, _a, _b, onError, _c, _d;
404
+ return __generator(this, function (_e) {
405
+ switch (_e.label) {
406
+ case 0:
407
+ if (!result.accepted) return [3 /*break*/, 2];
408
+ onSend_1 = this.options.onSend;
409
+ _a = this.appendHookError;
410
+ _b = [hookErrors,
411
+ "onSend"];
412
+ return [4 /*yield*/, this.invokeHook(onSend_1 ? function () { return onSend_1(context, result); } : undefined, "onSend")];
413
+ case 1:
414
+ _a.apply(this, _b.concat([_e.sent()]));
97
415
  return [2 /*return*/];
416
+ case 2:
417
+ onError = this.options.onError;
418
+ _c = this.appendHookError;
419
+ _d = [hookErrors,
420
+ "onError"];
421
+ return [4 /*yield*/, this.invokeHook(onError ? function () { return onError(context, result); } : undefined, "onError")];
422
+ case 3:
423
+ _c.apply(this, _d.concat([_e.sent()]));
424
+ return [2 /*return*/];
425
+ }
426
+ });
427
+ });
428
+ };
429
+ CommsService.prototype.retryOnce = function (context, firstResult, retry, hookErrors) {
430
+ return __awaiter(this, void 0, void 0, function () {
431
+ var onRetry, _a, _b, secondResult;
432
+ return __generator(this, function (_c) {
433
+ switch (_c.label) {
434
+ case 0:
435
+ if (!isTransientFailure(firstResult)) {
436
+ return [2 /*return*/, { attempts: [firstResult], result: firstResult }];
437
+ }
438
+ context.isRetry = true;
439
+ context.attempt = 2;
440
+ onRetry = this.options.onRetry;
441
+ _a = this.appendHookError;
442
+ _b = [hookErrors,
443
+ "onRetry"];
444
+ return [4 /*yield*/, this.invokeHook(onRetry ? function () { return onRetry(context, firstResult); } : undefined, "onRetry")];
445
+ case 1:
446
+ _a.apply(this, _b.concat([_c.sent()]));
447
+ return [4 /*yield*/, retry()];
448
+ case 2:
449
+ secondResult = _c.sent();
450
+ return [2 /*return*/, { attempts: [firstResult, secondResult], result: secondResult }];
451
+ }
452
+ });
453
+ });
454
+ };
455
+ CommsService.prototype.persistRetry = function (logged, context, hookErrors, provider, result) {
456
+ return __awaiter(this, void 0, void 0, function () {
457
+ var payload;
458
+ return __generator(this, function (_a) {
459
+ if (!logged) {
460
+ return [2 /*return*/, null];
461
+ }
462
+ payload = this.resolvePayload(context, hookErrors);
463
+ return [2 /*return*/, commsMessage_1.CommsMessage.appendAttempt({
464
+ attempt: this.attemptFromResult(provider, result),
465
+ error: result.error,
466
+ errorClass: result.errorClass,
467
+ errorCode: result.errorCode,
468
+ id: logged._id,
469
+ metadata: Object.keys(hookErrors).length > 0 ? { hookErrors: hookErrors } : undefined,
470
+ payload: payload,
471
+ payloadExpiresAt: payload === undefined ? undefined : this.payloadExpiresAt(),
472
+ providerMessageId: result.providerMessageId,
473
+ status: result.accepted ? "sent" : "failed",
474
+ })];
475
+ });
476
+ });
477
+ };
478
+ CommsService.prototype.finalizeWithRetry = function (_a) {
479
+ return __awaiter(this, arguments, void 0, function (_b) {
480
+ var logged, retried, finalLogged;
481
+ var _c;
482
+ var context = _b.context, first = _b.first, hookErrors = _b.hookErrors, logFields = _b.logFields, provider = _b.provider, retry = _b.retry;
483
+ return __generator(this, function (_d) {
484
+ switch (_d.label) {
485
+ case 0: return [4 /*yield*/, this.logResult({
486
+ attempts: [this.attemptFromResult(provider, first)],
487
+ channel: logFields.channel,
488
+ context: context,
489
+ hookErrors: hookErrors,
490
+ metadata: logFields.metadata,
491
+ provider: provider,
492
+ result: first,
493
+ status: first.accepted ? "sent" : "failed",
494
+ subject: logFields.subject,
495
+ templateId: logFields.templateId,
496
+ to: logFields.to,
497
+ userId: logFields.userId,
498
+ })];
499
+ case 1:
500
+ logged = _d.sent();
501
+ return [4 /*yield*/, this.retryOnce(context, first, retry, hookErrors)];
502
+ case 2:
503
+ retried = _d.sent();
504
+ finalLogged = logged;
505
+ if (!(retried.attempts.length > 1)) return [3 /*break*/, 4];
506
+ return [4 /*yield*/, this.persistRetry(logged, context, hookErrors, provider, retried.result)];
507
+ case 3:
508
+ finalLogged =
509
+ (_c = (_d.sent())) !== null && _c !== void 0 ? _c : logged;
510
+ _d.label = 4;
511
+ case 4: return [4 /*yield*/, this.notifyOutcomeHooks(context, retried.result, hookErrors)];
512
+ case 5:
513
+ _d.sent();
514
+ return [4 /*yield*/, this.patchHookErrors(finalLogged, hookErrors)];
515
+ case 6:
516
+ _d.sent();
517
+ return [2 /*return*/, retried.result];
518
+ }
519
+ });
520
+ });
521
+ };
522
+ CommsService.prototype.cancelledResult = function () {
523
+ return {
524
+ accepted: false,
525
+ error: CANCELLED_ERROR,
526
+ errorClass: "permanent",
527
+ errorCode: "before-send-cancel",
528
+ };
529
+ };
530
+ CommsService.prototype.sendMailOnce = function (provider, message) {
531
+ return __awaiter(this, void 0, void 0, function () {
532
+ var error_4;
533
+ return __generator(this, function (_a) {
534
+ switch (_a.label) {
535
+ case 0:
536
+ _a.trys.push([0, 2, , 3]);
537
+ return [4 /*yield*/, provider.sendMail(message)];
538
+ case 1: return [2 /*return*/, _a.sent()];
539
+ case 2:
540
+ error_4 = _a.sent();
541
+ return [2 /*return*/, providerThrowResult(error_4)];
542
+ case 3: return [2 /*return*/];
543
+ }
544
+ });
545
+ });
546
+ };
547
+ CommsService.prototype.sendSmsOnce = function (provider, message) {
548
+ return __awaiter(this, void 0, void 0, function () {
549
+ var error_5;
550
+ return __generator(this, function (_a) {
551
+ switch (_a.label) {
552
+ case 0:
553
+ _a.trys.push([0, 2, , 3]);
554
+ return [4 /*yield*/, provider.sendSms(message)];
555
+ case 1: return [2 /*return*/, _a.sent()];
556
+ case 2:
557
+ error_5 = _a.sent();
558
+ return [2 /*return*/, providerThrowResult(error_5)];
559
+ case 3: return [2 /*return*/];
560
+ }
561
+ });
562
+ });
563
+ };
564
+ CommsService.prototype.sendPushOnce = function (provider, message) {
565
+ return __awaiter(this, void 0, void 0, function () {
566
+ var error_6;
567
+ return __generator(this, function (_a) {
568
+ switch (_a.label) {
569
+ case 0:
570
+ _a.trys.push([0, 2, , 3]);
571
+ return [4 /*yield*/, provider.sendPush(message)];
572
+ case 1: return [2 /*return*/, _a.sent()];
573
+ case 2:
574
+ error_6 = _a.sent();
575
+ return [2 /*return*/, message.tokens.map(function () { return providerThrowResult(error_6); })];
576
+ case 3: return [2 /*return*/];
577
+ }
578
+ });
579
+ });
580
+ };
581
+ CommsService.prototype.startVerificationOnce = function (provider, options) {
582
+ return __awaiter(this, void 0, void 0, function () {
583
+ var error_7;
584
+ return __generator(this, function (_a) {
585
+ switch (_a.label) {
586
+ case 0:
587
+ _a.trys.push([0, 2, , 3]);
588
+ return [4 /*yield*/, provider.startVerification(options)];
589
+ case 1: return [2 /*return*/, _a.sent()];
590
+ case 2:
591
+ error_7 = _a.sent();
592
+ return [2 /*return*/, providerThrowResult(error_7)];
593
+ case 3: return [2 /*return*/];
98
594
  }
99
595
  });
100
596
  });
@@ -139,100 +635,139 @@ var CommsService = /** @class */ (function () {
139
635
  api_1.logger.warn("[comms] Verification provider not configured; using console provider");
140
636
  return this.consoleVerification;
141
637
  };
638
+ CommsService.prototype.applyMailDefaults = function (message) {
639
+ var _a;
640
+ return __assign(__assign({}, message), { from: (_a = message.from) !== null && _a !== void 0 ? _a : this.options.defaultFrom });
641
+ };
142
642
  CommsService.prototype.sendMail = function (message) {
143
643
  return __awaiter(this, void 0, void 0, function () {
144
- var provider, resolvedMessage, result, error_1;
145
- var _a;
146
- return __generator(this, function (_b) {
147
- switch (_b.label) {
644
+ var provider, hookErrors, context, before, activeMessage, result, first;
645
+ var _this = this;
646
+ return __generator(this, function (_a) {
647
+ switch (_a.label) {
148
648
  case 0:
149
649
  provider = this.mailProvider();
150
- resolvedMessage = __assign(__assign({}, message), { from: (_a = message.from) !== null && _a !== void 0 ? _a : this.options.defaultFrom });
151
- _b.label = 1;
650
+ hookErrors = {};
651
+ context = {
652
+ attempt: 1,
653
+ channel: "mail",
654
+ isRetry: false,
655
+ message: this.applyMailDefaults(message),
656
+ provider: provider.id,
657
+ };
658
+ return [4 /*yield*/, this.applyBeforeSend(context, hookErrors)];
152
659
  case 1:
153
- _b.trys.push([1, 4, , 6]);
154
- return [4 /*yield*/, provider.sendMail(resolvedMessage)];
155
- case 2:
156
- result = _b.sent();
660
+ before = _a.sent();
661
+ activeMessage = this.applyMailDefaults(before.message);
662
+ context.message = activeMessage;
663
+ if (!before.cancel) return [3 /*break*/, 3];
664
+ result = this.cancelledResult();
157
665
  return [4 /*yield*/, this.logResult({
666
+ attempts: [this.attemptFromResult(provider.id, result)],
158
667
  channel: "mail",
668
+ context: context,
669
+ hookErrors: hookErrors,
159
670
  provider: provider.id,
160
671
  result: result,
161
- subject: message.subject,
162
- to: message.to,
672
+ status: "cancelled",
673
+ subject: activeMessage.subject,
674
+ templateId: activeMessage.templateId,
675
+ to: activeMessage.to,
163
676
  })];
164
- case 3:
165
- _b.sent();
677
+ case 2:
678
+ _a.sent();
166
679
  return [2 /*return*/, result];
680
+ case 3: return [4 /*yield*/, this.sendMailOnce(provider, activeMessage)];
167
681
  case 4:
168
- error_1 = _b.sent();
169
- return [4 /*yield*/, this.logResult({
170
- channel: "mail",
682
+ first = _a.sent();
683
+ return [2 /*return*/, this.finalizeWithRetry({
684
+ context: context,
685
+ first: first,
686
+ hookErrors: hookErrors,
687
+ logFields: {
688
+ channel: "mail",
689
+ metadata: first.metadata,
690
+ subject: activeMessage.subject,
691
+ templateId: activeMessage.templateId,
692
+ to: activeMessage.to,
693
+ },
171
694
  provider: provider.id,
172
- result: { accepted: false, error: "Provider send failed" },
173
- subject: message.subject,
174
- to: message.to,
695
+ retry: function () { return _this.sendMailOnce(provider, activeMessage); },
175
696
  })];
176
- case 5:
177
- _b.sent();
178
- throw error_1;
179
- case 6: return [2 /*return*/];
180
697
  }
181
698
  });
182
699
  });
183
700
  };
184
701
  CommsService.prototype.sendSms = function (message) {
185
702
  return __awaiter(this, void 0, void 0, function () {
186
- var provider, result, error_2;
703
+ var provider, hookErrors, context, before, activeMessage, result, first;
704
+ var _this = this;
187
705
  return __generator(this, function (_a) {
188
706
  switch (_a.label) {
189
707
  case 0:
190
708
  provider = this.smsProvider();
191
- _a.label = 1;
709
+ hookErrors = {};
710
+ context = {
711
+ attempt: 1,
712
+ channel: "sms",
713
+ isRetry: false,
714
+ message: message,
715
+ provider: provider.id,
716
+ };
717
+ return [4 /*yield*/, this.applyBeforeSend(context, hookErrors)];
192
718
  case 1:
193
- _a.trys.push([1, 4, , 6]);
194
- return [4 /*yield*/, provider.sendSms(message)];
195
- case 2:
196
- result = _a.sent();
719
+ before = _a.sent();
720
+ activeMessage = before.message;
721
+ context.message = activeMessage;
722
+ if (!before.cancel) return [3 /*break*/, 3];
723
+ result = this.cancelledResult();
197
724
  return [4 /*yield*/, this.logResult({
725
+ attempts: [this.attemptFromResult(provider.id, result)],
198
726
  channel: "sms",
727
+ context: context,
728
+ hookErrors: hookErrors,
199
729
  provider: provider.id,
200
730
  result: result,
201
- to: message.to,
731
+ status: "cancelled",
732
+ to: activeMessage.to,
202
733
  })];
203
- case 3:
734
+ case 2:
204
735
  _a.sent();
205
736
  return [2 /*return*/, result];
737
+ case 3: return [4 /*yield*/, this.sendSmsOnce(provider, activeMessage)];
206
738
  case 4:
207
- error_2 = _a.sent();
208
- return [4 /*yield*/, this.logResult({
209
- channel: "sms",
739
+ first = _a.sent();
740
+ return [2 /*return*/, this.finalizeWithRetry({
741
+ context: context,
742
+ first: first,
743
+ hookErrors: hookErrors,
744
+ logFields: {
745
+ channel: "sms",
746
+ to: activeMessage.to,
747
+ },
210
748
  provider: provider.id,
211
- result: { accepted: false, error: "Provider send failed" },
212
- to: message.to,
749
+ retry: function () { return _this.sendSmsOnce(provider, activeMessage); },
213
750
  })];
214
- case 5:
215
- _a.sent();
216
- throw error_2;
217
- case 6: return [2 /*return*/];
218
751
  }
219
752
  });
220
753
  });
221
754
  };
222
755
  CommsService.prototype.sendPushToUser = function (message) {
223
756
  return __awaiter(this, void 0, void 0, function () {
224
- var provider, tokens, providerMessage, results, error_3, normalizedResults;
757
+ var provider, hookErrors, tokens, tokenDocs, providerMessage, context, before, activeMessage, result_1, sendTokens, firstByToken, _a, _b, loggedByToken, retryTokens, retryTokenSet, beforeRetryHookErrors, finalByToken, retryContext, onRetry_1, firstTransient_1, _c, _d, retryByToken_1, _e, _f;
225
758
  var _this = this;
226
- return __generator(this, function (_a) {
227
- switch (_a.label) {
759
+ return __generator(this, function (_g) {
760
+ switch (_g.label) {
228
761
  case 0:
229
762
  provider = this.pushProvider();
763
+ hookErrors = {};
230
764
  return [4 /*yield*/, pushToken_1.PushToken.find({ active: true, userId: message.userId })];
231
765
  case 1:
232
- tokens = _a.sent();
766
+ tokens = _g.sent();
233
767
  if (tokens.length === 0) {
234
768
  return [2 /*return*/, []];
235
769
  }
770
+ tokenDocs = new Map(tokens.map(function (token) { return [token.token, token]; }));
236
771
  providerMessage = {
237
772
  badge: message.badge,
238
773
  body: message.body,
@@ -241,142 +776,288 @@ var CommsService = /** @class */ (function () {
241
776
  title: message.title,
242
777
  tokens: tokens.map(function (token) { return token.token; }),
243
778
  };
244
- _a.label = 2;
779
+ context = {
780
+ attempt: 1,
781
+ channel: "push",
782
+ isRetry: false,
783
+ message: providerMessage,
784
+ provider: provider.id,
785
+ userId: String(message.userId),
786
+ };
787
+ return [4 /*yield*/, this.applyBeforeSend(context, hookErrors)];
245
788
  case 2:
246
- _a.trys.push([2, 4, , 6]);
247
- return [4 /*yield*/, provider.sendPush(providerMessage)];
248
- case 3:
249
- results = _a.sent();
250
- return [3 /*break*/, 6];
251
- case 4:
252
- error_3 = _a.sent();
789
+ before = _g.sent();
790
+ activeMessage = before.message;
791
+ context.message = activeMessage;
792
+ if (!before.cancel) return [3 /*break*/, 4];
793
+ result_1 = this.cancelledResult();
253
794
  return [4 /*yield*/, Promise.all(tokens.map(function (token) {
254
795
  return _this.logResult({
796
+ attempts: [_this.attemptFromResult(provider.id, result_1)],
255
797
  channel: "push",
798
+ context: _this.cloneContext(context),
799
+ hookErrors: hookErrors,
256
800
  provider: provider.id,
257
- result: { accepted: false, error: "Provider send failed" },
801
+ result: result_1,
802
+ status: "cancelled",
258
803
  to: token.token,
259
804
  userId: String(message.userId),
260
805
  });
261
806
  }))];
807
+ case 3:
808
+ _g.sent();
809
+ return [2 /*return*/, tokens.map(function () { return result_1; })];
810
+ case 4:
811
+ sendTokens = activeMessage.tokens;
812
+ if (sendTokens.length === 0) {
813
+ return [2 /*return*/, []];
814
+ }
815
+ _a = this.resultsByToken;
816
+ _b = [sendTokens];
817
+ return [4 /*yield*/, this.sendPushOnce(provider, activeMessage)];
262
818
  case 5:
263
- _a.sent();
264
- throw error_3;
265
- case 6:
266
- normalizedResults = tokens.map(function (_token, index) {
267
- var _a;
268
- return (_a = results[index]) !== null && _a !== void 0 ? _a : {
269
- accepted: false,
270
- error: "Provider returned no result for token",
271
- };
272
- });
273
- return [4 /*yield*/, Promise.all(tokens.map(function (token, index) { return __awaiter(_this, void 0, void 0, function () {
274
- var result;
819
+ firstByToken = _a.apply(this, _b.concat([_g.sent()]));
820
+ loggedByToken = new Map();
821
+ return [4 /*yield*/, Promise.all(sendTokens.map(function (tokenValue) { return __awaiter(_this, void 0, void 0, function () {
822
+ var result, tokenContext, logged;
275
823
  return __generator(this, function (_a) {
276
824
  switch (_a.label) {
277
825
  case 0:
278
- result = normalizedResults[index];
826
+ result = firstByToken.get(tokenValue);
827
+ tokenContext = this.cloneContext(context);
279
828
  return [4 /*yield*/, this.logResult({
829
+ attempts: [this.attemptFromResult(provider.id, result)],
280
830
  channel: "push",
831
+ context: tokenContext,
832
+ hookErrors: hookErrors,
281
833
  provider: provider.id,
282
834
  result: result,
283
- to: token.token,
835
+ status: result.accepted ? "sent" : "failed",
836
+ to: tokenValue,
284
837
  userId: String(message.userId),
285
838
  })];
286
839
  case 1:
287
- _a.sent();
288
- if (!(!result.accepted && result.isPermanentFailure)) return [3 /*break*/, 3];
289
- token.active = false;
290
- return [4 /*yield*/, token.save()];
291
- case 2:
292
- _a.sent();
293
- _a.label = 3;
294
- case 3: return [2 /*return*/];
840
+ logged = _a.sent();
841
+ loggedByToken.set(tokenValue, logged);
842
+ return [2 /*return*/];
295
843
  }
296
844
  });
297
845
  }); }))];
846
+ case 6:
847
+ _g.sent();
848
+ retryTokens = sendTokens.filter(function (tokenValue) {
849
+ return isTransientFailure(firstByToken.get(tokenValue));
850
+ });
851
+ retryTokenSet = new Set(retryTokens);
852
+ beforeRetryHookErrors = this.cloneHookErrors(hookErrors);
853
+ finalByToken = new Map(firstByToken);
854
+ retryContext = this.cloneContext(context, { attempt: 2, isRetry: true });
855
+ if (!(retryTokens.length > 0)) return [3 /*break*/, 10];
856
+ onRetry_1 = this.options.onRetry;
857
+ firstTransient_1 = firstByToken.get(retryTokens[0]);
858
+ _c = this.appendHookError;
859
+ _d = [hookErrors,
860
+ "onRetry"];
861
+ return [4 /*yield*/, this.invokeHook(onRetry_1 ? function () { return onRetry_1(retryContext, firstTransient_1); } : undefined, "onRetry")];
298
862
  case 7:
299
- _a.sent();
300
- return [2 /*return*/, normalizedResults];
863
+ _c.apply(this, _d.concat([_g.sent()]));
864
+ _e = this.resultsByToken;
865
+ _f = [retryTokens];
866
+ return [4 /*yield*/, this.sendPushOnce(provider, __assign(__assign({}, activeMessage), { tokens: retryTokens }))];
867
+ case 8:
868
+ retryByToken_1 = _e.apply(this, _f.concat([_g.sent()]));
869
+ return [4 /*yield*/, Promise.all(retryTokens.map(function (tokenValue) { return __awaiter(_this, void 0, void 0, function () {
870
+ var retryResult, tokenHookErrors, logged, appended;
871
+ var _a;
872
+ return __generator(this, function (_b) {
873
+ switch (_b.label) {
874
+ case 0:
875
+ retryResult = retryByToken_1.get(tokenValue);
876
+ finalByToken.set(tokenValue, retryResult);
877
+ tokenHookErrors = this.cloneHookErrors(beforeRetryHookErrors);
878
+ if (hookErrors.onRetry) {
879
+ tokenHookErrors.onRetry = __spreadArray([], __read(hookErrors.onRetry), false);
880
+ }
881
+ logged = (_a = loggedByToken.get(tokenValue)) !== null && _a !== void 0 ? _a : null;
882
+ return [4 /*yield*/, this.persistRetry(logged, this.cloneContext(retryContext, {
883
+ messageId: logged ? String(logged._id) : undefined,
884
+ }), tokenHookErrors, provider.id, retryResult)];
885
+ case 1:
886
+ appended = _b.sent();
887
+ if (appended) {
888
+ loggedByToken.set(tokenValue, appended);
889
+ }
890
+ return [2 /*return*/];
891
+ }
892
+ });
893
+ }); }))];
894
+ case 9:
895
+ _g.sent();
896
+ _g.label = 10;
897
+ case 10: return [4 /*yield*/, Promise.all(sendTokens.map(function (tokenValue) { return __awaiter(_this, void 0, void 0, function () {
898
+ var result, tokenHookErrors, logged, didRetry, tokenDoc;
899
+ var _a;
900
+ return __generator(this, function (_b) {
901
+ switch (_b.label) {
902
+ case 0:
903
+ result = finalByToken.get(tokenValue);
904
+ tokenHookErrors = this.cloneHookErrors(beforeRetryHookErrors);
905
+ if (retryTokenSet.has(tokenValue) && hookErrors.onRetry) {
906
+ tokenHookErrors.onRetry = __spreadArray([], __read(hookErrors.onRetry), false);
907
+ }
908
+ logged = (_a = loggedByToken.get(tokenValue)) !== null && _a !== void 0 ? _a : null;
909
+ didRetry = retryTokenSet.has(tokenValue);
910
+ return [4 /*yield*/, this.notifyOutcomeHooks(this.cloneContext(context, {
911
+ attempt: didRetry ? 2 : 1,
912
+ isRetry: didRetry,
913
+ messageId: logged ? String(logged._id) : undefined,
914
+ }), result, tokenHookErrors)];
915
+ case 1:
916
+ _b.sent();
917
+ return [4 /*yield*/, this.patchHookErrors(logged, tokenHookErrors)];
918
+ case 2:
919
+ _b.sent();
920
+ tokenDoc = tokenDocs.get(tokenValue);
921
+ if (!(tokenDoc && !result.accepted && isPermanentPushFailure(result))) return [3 /*break*/, 4];
922
+ tokenDoc.active = false;
923
+ return [4 /*yield*/, tokenDoc.save()];
924
+ case 3:
925
+ _b.sent();
926
+ _b.label = 4;
927
+ case 4: return [2 /*return*/];
928
+ }
929
+ });
930
+ }); }))];
931
+ case 11:
932
+ _g.sent();
933
+ return [2 /*return*/, sendTokens.map(function (tokenValue) { return finalByToken.get(tokenValue); })];
301
934
  }
302
935
  });
303
936
  });
304
937
  };
305
938
  CommsService.prototype.startVerification = function (options) {
306
939
  return __awaiter(this, void 0, void 0, function () {
307
- var provider, result, error_4;
940
+ var provider, hookErrors, context, before, activeOptions, result, first;
941
+ var _this = this;
308
942
  return __generator(this, function (_a) {
309
943
  switch (_a.label) {
310
944
  case 0:
311
945
  provider = this.verificationProvider();
312
- _a.label = 1;
946
+ hookErrors = {};
947
+ context = {
948
+ attempt: 1,
949
+ channel: "verification",
950
+ isRetry: false,
951
+ message: options,
952
+ provider: provider.id,
953
+ };
954
+ return [4 /*yield*/, this.applyBeforeSend(context, hookErrors)];
313
955
  case 1:
314
- _a.trys.push([1, 4, , 6]);
315
- return [4 /*yield*/, provider.startVerification(options)];
316
- case 2:
317
- result = _a.sent();
956
+ before = _a.sent();
957
+ activeOptions = before.message;
958
+ context.message = activeOptions;
959
+ if (!before.cancel) return [3 /*break*/, 3];
960
+ result = this.cancelledResult();
318
961
  return [4 /*yield*/, this.logResult({
962
+ attempts: [this.attemptFromResult(provider.id, result)],
319
963
  channel: "verification",
320
- metadata: { verificationChannel: options.channel },
964
+ context: context,
965
+ hookErrors: hookErrors,
966
+ metadata: { verificationChannel: activeOptions.channel },
321
967
  provider: provider.id,
322
968
  result: result,
323
- to: options.to,
969
+ status: "cancelled",
970
+ to: activeOptions.to,
324
971
  })];
325
- case 3:
972
+ case 2:
326
973
  _a.sent();
327
974
  return [2 /*return*/, result];
975
+ case 3: return [4 /*yield*/, this.startVerificationOnce(provider, activeOptions)];
328
976
  case 4:
329
- error_4 = _a.sent();
330
- return [4 /*yield*/, this.logResult({
331
- channel: "verification",
332
- metadata: { verificationChannel: options.channel },
977
+ first = _a.sent();
978
+ return [2 /*return*/, this.finalizeWithRetry({
979
+ context: context,
980
+ first: first,
981
+ hookErrors: hookErrors,
982
+ logFields: {
983
+ channel: "verification",
984
+ metadata: { verificationChannel: activeOptions.channel },
985
+ to: activeOptions.to,
986
+ },
333
987
  provider: provider.id,
334
- result: { accepted: false, error: "Provider send failed" },
335
- to: options.to,
988
+ retry: function () { return _this.startVerificationOnce(provider, activeOptions); },
336
989
  })];
337
- case 5:
338
- _a.sent();
339
- throw error_4;
340
- case 6: return [2 /*return*/];
341
990
  }
342
991
  });
343
992
  });
344
993
  };
345
994
  CommsService.prototype.checkVerification = function (options) {
346
995
  return __awaiter(this, void 0, void 0, function () {
347
- var provider, result, error_5;
996
+ var provider, hookErrors, context, result, loggedResult, logged, error_8, loggedResult, logged;
348
997
  var _a;
349
998
  return __generator(this, function (_b) {
350
999
  switch (_b.label) {
351
1000
  case 0:
352
1001
  provider = this.verificationProvider();
1002
+ hookErrors = {};
1003
+ context = {
1004
+ attempt: 1,
1005
+ channel: "verification",
1006
+ isRetry: false,
1007
+ message: { channel: "sms", to: options.to },
1008
+ provider: provider.id,
1009
+ };
353
1010
  _b.label = 1;
354
1011
  case 1:
355
- _b.trys.push([1, 4, , 6]);
1012
+ _b.trys.push([1, 6, , 10]);
356
1013
  return [4 /*yield*/, provider.checkVerification(options)];
357
1014
  case 2:
358
1015
  result = _b.sent();
1016
+ loggedResult = __assign({ accepted: result.valid }, (result.valid ? {} : { error: (_a = result.error) !== null && _a !== void 0 ? _a : "Verification check failed" }));
359
1017
  return [4 /*yield*/, this.logResult({
1018
+ attempts: [this.attemptFromResult(provider.id, loggedResult)],
360
1019
  channel: "verification",
1020
+ context: context,
1021
+ hookErrors: hookErrors,
1022
+ omitPayload: true,
361
1023
  provider: provider.id,
362
- result: __assign({ accepted: result.valid }, (result.valid ? {} : { error: (_a = result.error) !== null && _a !== void 0 ? _a : "Verification check failed" })),
1024
+ result: loggedResult,
1025
+ status: loggedResult.accepted ? "sent" : "failed",
363
1026
  to: options.to,
364
1027
  })];
365
1028
  case 3:
1029
+ logged = _b.sent();
1030
+ return [4 /*yield*/, this.notifyOutcomeHooks(context, loggedResult, hookErrors)];
1031
+ case 4:
1032
+ _b.sent();
1033
+ return [4 /*yield*/, this.patchHookErrors(logged, hookErrors)];
1034
+ case 5:
366
1035
  _b.sent();
367
1036
  return [2 /*return*/, result];
368
- case 4:
369
- error_5 = _b.sent();
1037
+ case 6:
1038
+ error_8 = _b.sent();
1039
+ loggedResult = providerThrowResult(error_8);
370
1040
  return [4 /*yield*/, this.logResult({
1041
+ attempts: [this.attemptFromResult(provider.id, loggedResult)],
371
1042
  channel: "verification",
1043
+ context: context,
1044
+ hookErrors: hookErrors,
1045
+ omitPayload: true,
372
1046
  provider: provider.id,
373
- result: { accepted: false, error: "Provider check failed" },
1047
+ result: loggedResult,
1048
+ status: "failed",
374
1049
  to: options.to,
375
1050
  })];
376
- case 5:
1051
+ case 7:
1052
+ logged = _b.sent();
1053
+ return [4 /*yield*/, this.notifyOutcomeHooks(context, loggedResult, hookErrors)];
1054
+ case 8:
377
1055
  _b.sent();
378
- throw error_5;
379
- case 6: return [2 /*return*/];
1056
+ return [4 /*yield*/, this.patchHookErrors(logged, hookErrors)];
1057
+ case 9:
1058
+ _b.sent();
1059
+ return [2 /*return*/, { error: loggedResult.error, valid: false }];
1060
+ case 10: return [2 /*return*/];
380
1061
  }
381
1062
  });
382
1063
  });