@oneuptime/common 14.0.7 → 14.0.8

package/build/dist/Types/SafeHtml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SafeHtml.js","sourceRoot":"","sources":["../../../Types/SafeHtml.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;;AAEH;;;GAGG;AACH,MAAM,eAAe,GAAkB,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAExE,MAAqB,QAAQ;IAM3B,YAAoB,IAAY;QALhC,qEAAqE;QACrD,QAAiB,GAAY,IAAI,CAAC;QAKhD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,eAAe,CAAC,IAA+B;QAC3D,OAAO,IAAI,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;IAClC,CAAC;IAED,oDAAoD;IAC7C,MAAM,CAAC,aAAa,CAAC,IAA+B;QACzD,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,MAAM,CAAC,IAAY;QAC/B,OAAO,MAAM,CAAC,IAAI,CAAC;aAChB,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;aACtB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;aACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;aACrB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;aACvB,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC5B,CAAC;IAEM,MAAM,CAAC,UAAU,CAAC,KAAc;QACrC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;YACzB,KAAK,KAAK,IAAI;YACb,KAAyC,CAAC,eAAe,CAAC,KAAK,IAAI,CACrE,CAAC;IACJ,CAAC;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAEM,QAAQ;QACb,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;CACF;KAvDkB,eAAe;eAFb,QAAQ"}

package/build/dist/Types/StatusPage/IncidentCreatedRenotify.js

@@ -0,0 +1,117 @@
+import IncidentScopeAddedPagesNotification from "./IncidentScopeAddedPagesNotification";
+import StatusPageSubscriberNotificationStatus from "./StatusPageSubscriberNotificationStatus";
+class IncidentCreatedRenotify {
+    /*
+     * Only a real yes counts. The flag arrives over JSON, so accept the string
+     * form a hand-written API request might send, and nothing looser: a stray
+     * "false" or 1 must never email every subscriber of a status page.
+     */
+    static isRequested(miscDataProps) {
+        if (!miscDataProps || typeof miscDataProps !== "object") {
+            return false;
+        }
+        const value = miscDataProps[this.miscDataKey];
+        return value === true || value === "true";
+    }
+    static getMiscDataProps() {
+        return {
+            [this.miscDataKey]: true,
+        };
+    }
+    /*
+     * Whether publishing this incident may queue its 'created' notification
+     * again, given what is stored for it right now:
+     *
+     * - it is hidden today, so this really is the publish;
+     * - notifying on creation is on. An incident created with notifications
+     *   off was deliberately kept quiet, and publishing does not change that;
+     * - it is not private. Private incidents are hidden from every status page,
+     *   so there is nothing to publish;
+     * - and there is someone left to tell. Either its 'created' notification
+     *   was Skipped, so nobody was told; or it went out (Success, or Failed
+     *   part-way) and the incident is limited to status pages its record does
+     *   not list - typically pages added while it was hidden (see
+     *   hasUntoldStatusPages). Pending and InProgress are on their way already
+     *   (and a Pending send reads the incident when it goes out, so it will see
+     *   it visible).
+     */
+    static canRenotifyOnPublish(incident) {
+        if (incident.isVisibleOnStatusPage === true ||
+            incident.shouldStatusPageSubscribersBeNotifiedOnIncidentCreated !==
+                true ||
+            incident.isPrivate === true) {
+            return false;
+        }
+        return (incident.subscriberNotificationStatusOnIncidentCreated ===
+            StatusPageSubscriberNotificationStatus.Skipped ||
+            this.hasUntoldStatusPages(incident));
+    }
+    /*
+     * Whether a notification that already went out left status pages of the
+     * incident's scope untold: its record exists and misses one of them. Pages
+     * added while the incident was hidden land here, as do pages whose send
+     * failed. A page in the scope that lists none of the incident's monitors,
+     * or does not show incidents, is never told either; offering the checkbox
+     * for it sends nothing, and the incident feed says so.
+     *
+     * An incident without a record is not offered it: its notification went out
+     * before the record existed, to every page that listed its monitors (see
+     * IncidentScopeAddedPagesNotification).
+     */
+    static hasUntoldStatusPages(incident) {
+        if (incident.subscriberNotificationStatusOnIncidentCreated !==
+            StatusPageSubscriberNotificationStatus.Success &&
+            incident.subscriberNotificationStatusOnIncidentCreated !==
+                StatusPageSubscriberNotificationStatus.Failed) {
+            return false;
+        }
+        const recorded = IncidentScopeAddedPagesNotification.getRecordedStatusPageIds(incident.statusPagesNotifiedOnCreation);
+        if (recorded === null) {
+            return false;
+        }
+        return IncidentScopeAddedPagesNotification.normalizeStatusPageIds(incident.statusPages).some((id) => {
+            return !recorded.includes(id);
+        });
+    }
+    // The checkbox's description, for the case canRenotifyOnPublish found.
+    static getFormFieldDescription(incident) {
+        return incident.subscriberNotificationStatusOnIncidentCreated ===
+            StatusPageSubscriberNotificationStatus.Skipped
+            ? this.formFieldDescription
+            : this.untoldStatusPagesFormFieldDescription;
+    }
+    /*
+     * The checkbox starts ticked while the incident is unresolved - publishing
+     * a live incident is the moment its audience should hear about it - and
+     * unticked once it is resolved, so making an old incident visible for the
+     * record does not announce it as new.
+     */
+    static isTickedByDefault(data) {
+        return data.isResolved !== true;
+    }
+    /*
+     * Whether a stored status and message say the 'created' notification was
+     * skipped because the incident was hidden from status pages.
+     */
+    static isHiddenFromStatusPagesSkip(data) {
+        return (data.status === StatusPageSubscriberNotificationStatus.Skipped &&
+            data.message === this.hiddenFromStatusPagesMessage);
+    }
+}
+// The misc data prop an update request carries to ask for the notification.
+IncidentCreatedRenotify.miscDataKey = "notifySubscribersOfIncidentCreatedOnPublish";
+/*
+ * Why the worker skipped the 'created' notification of a hidden incident.
+ * The data migration that settled incidents left InProgress by the old
+ * worker writes the same text, so both read alike on the dashboard.
+ */
+IncidentCreatedRenotify.hiddenFromStatusPagesMessage = "Incident is not visible on status pages. Skipping notifications to subscribers.";
+// How the dashboard labels that skip next to the notification status.
+IncidentCreatedRenotify.hiddenFromStatusPagesLabel = "Skipped: hidden from status pages";
+IncidentCreatedRenotify.queuedMessage = "Incident published on status pages. Subscribers will be notified that this incident was created.";
+IncidentCreatedRenotify.formFieldTitle = "Notify subscribers that this incident was created";
+IncidentCreatedRenotify.formFieldDescription = "Subscribers were not told about this incident because it was hidden from status pages. Tick this to send them the incident-created notification now. It starts unticked for resolved incidents, so publishing an old incident for the record does not announce it as new.";
+// The same checkbox, for an incident whose earlier subscribers were told.
+IncidentCreatedRenotify.untoldStatusPagesFormFieldDescription = "Some status pages this incident is limited to were never sent the notification that it was created, for example pages added while it was hidden. Tick this to send it to them now. Pages that were already told are not sent it again.";
+export default IncidentCreatedRenotify;
+//# sourceMappingURL=IncidentCreatedRenotify.js.map

package/build/dist/Types/StatusPage/IncidentCreatedRenotify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncidentCreatedRenotify.js","sourceRoot":"","sources":["../../../../Types/StatusPage/IncidentCreatedRenotify.ts"],"names":[],"mappings":"AACA,OAAO,mCAAmC,MAAM,uCAAuC,CAAC;AACxF,OAAO,sCAAsC,MAAM,0CAA0C,CAAC;AAyD9F,MAAqB,uBAAuB;IA8B1C;;;;OAIG;IACI,MAAM,CAAC,WAAW,CACvB,aAA4C;QAE5C,IAAI,CAAC,aAAa,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;YACxD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,KAAK,GAAY,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEvD,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC;IAC5C,CAAC;IAEM,MAAM,CAAC,gBAAgB;QAC5B,OAAO;YACL,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI;SACzB,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,CAAC,oBAAoB,CAChC,QAAsC;QAEtC,IACE,QAAQ,CAAC,qBAAqB,KAAK,IAAI;YACvC,QAAQ,CAAC,sDAAsD;gBAC7D,IAAI;YACN,QAAQ,CAAC,SAAS,KAAK,IAAI,EAC3B,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,CACL,QAAQ,CAAC,6CAA6C;YACpD,sCAAsC,CAAC,OAAO;YAChD,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CACpC,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,oBAAoB,CAChC,QAAsC;QAEtC,IACE,QAAQ,CAAC,6CAA6C;YACpD,sCAAsC,CAAC,OAAO;YAChD,QAAQ,CAAC,6CAA6C;gBACpD,sCAAsC,CAAC,MAAM,EAC/C,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,QAAQ,GACZ,mCAAmC,CAAC,wBAAwB,CAC1D,QAAQ,CAAC,6BAA6B,CACvC,CAAC;QAEJ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACtB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,mCAAmC,CAAC,sBAAsB,CAC/D,QAAQ,CAAC,WAAW,CACrB,CAAC,IAAI,CAAC,CAAC,EAAU,EAAW,EAAE;YAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,uEAAuE;IAChE,MAAM,CAAC,uBAAuB,CACnC,QAAsC;QAEtC,OAAO,QAAQ,CAAC,6CAA6C;YAC3D,sCAAsC,CAAC,OAAO;YAC9C,CAAC,CAAC,IAAI,CAAC,oBAAoB;YAC3B,CAAC,CAAC,IAAI,CAAC,qCAAqC,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,iBAAiB,CAAC,IAE/B;QACC,OAAO,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC;IAClC,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,2BAA2B,CAAC,IAGzC;QACC,OAAO,CACL,IAAI,CAAC,MAAM,KAAK,sCAAsC,CAAC,OAAO;YAC9D,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,4BAA4B,CACnD,CAAC;IACJ,CAAC;;AAlKD,4EAA4E;AACrD,mCAAW,GAChC,6CAA6C,CAAC;AAEhD;;;;GAIG;AACoB,oDAA4B,GACjD,iFAAiF,CAAC;AAEpF,sEAAsE;AAC/C,kDAA0B,GAC/C,mCAAmC,CAAC;AAEf,qCAAa,GAClC,kGAAkG,CAAC;AAE9E,sCAAc,GACnC,mDAAmD,CAAC;AAE/B,4CAAoB,GACzC,2QAA2Q,CAAC;AAE9Q,0EAA0E;AACnD,6DAAqC,GAC1D,wOAAwO,CAAC;eA5BxN,uBAAuB"}

package/build/dist/Types/StatusPage/IncidentCreatedResend.js

@@ -0,0 +1,86 @@
+import StatusPageSubscriberNotificationStatus from "./StatusPageSubscriberNotificationStatus";
+/*
+ * 'Resend to all pages' for the notification that an incident was created.
+ *
+ * That notification keeps a record of the status pages it was sent to in
+ * full (Incident.statusPagesNotifiedOnCreation), and the job skips them. Two
+ * ways of sending it again already existed, and both stay as they are:
+ *
+ * - setting subscriberNotificationStatusOnIncidentCreated back to Pending
+ *   (the API route, and the dashboard's Retry): IncidentService empties the
+ *   record in the same write, so it reaches every page again - except after
+ *   a failure, where Retry resumes after the pages the failed send finished,
+ *   so they are not sent it twice (see
+ *   IncidentService.clearCreatedNotificationRecordOnResend);
+ * - adding pages to the scope, or publishing a hidden incident, with their
+ *   checkboxes (IncidentScopeAddedPagesNotification, IncidentCreatedRenotify),
+ *   which tell only the pages the record does not list.
+ *
+ * What was missing is sending it to every page on purpose: after a failure,
+ * to start over rather than resume (a template or an SMTP setting was fixed
+ * since, and the pages that "went through" should get the corrected email
+ * too), and after a success, without relying on an implied rule. This misc
+ * data prop asks for exactly that. IncidentService turns it into a Pending
+ * status and an empty record, in the caller's own update, so the column
+ * check that runs after the hook decides whether the caller may.
+ *
+ * Like the other notification requests (SubscriberUpdateNotification,
+ * IncidentCreatedRenotify, IncidentScopeAddedPagesNotification) it is a misc
+ * data prop, not a column: a stored "resend" flag would either stick or have
+ * to be reset behind the caller's back.
+ *
+ * It is only accepted for a notification that went out - Success, or Failed
+ * part-way. A skipped one was never sent to anyone, and one that is Pending
+ * or being sent is on its way; see getRefusalReason.
+ */
+class IncidentCreatedResend {
+    /*
+     * Only a real yes counts. The flag arrives over JSON, so accept the string
+     * form a hand-written API request might send, and nothing looser: a stray
+     * "false" or 1 must never email every subscriber of every status page.
+     */
+    static isRequested(miscDataProps) {
+        if (!miscDataProps || typeof miscDataProps !== "object") {
+            return false;
+        }
+        const value = miscDataProps[this.miscDataKey];
+        return value === true || value === "true";
+    }
+    static getMiscDataProps() {
+        return {
+            [this.miscDataKey]: true,
+        };
+    }
+    /*
+     * Why a notification in `status` cannot be sent to every page again, or
+     * null when it can (it went out: Success, or Failed part-way).
+     */
+    static getRefusalReason(status) {
+        switch (status) {
+            case StatusPageSubscriberNotificationStatus.Success:
+            case StatusPageSubscriberNotificationStatus.Failed:
+                return null;
+            case StatusPageSubscriberNotificationStatus.Pending:
+            case StatusPageSubscriberNotificationStatus.InProgress:
+                return this.inFlightRefusalMessage;
+            default:
+                // Skipped, and a missing status, which the column's default rules out.
+                return this.skippedRefusalMessage;
+        }
+    }
+}
+// The misc data prop an update request carries to ask for the resend.
+IncidentCreatedResend.miscDataKey = "resendIncidentCreatedToAllStatusPages";
+// The status message of a notification queued by this request.
+IncidentCreatedResend.queuedMessage = "Queued to be sent again to every status page this incident reaches, including the pages that were already sent it.";
+/*
+ * The status message the dashboard's Retry writes: it resumes after the
+ * pages already reached.
+ */
+IncidentCreatedResend.retryQueuedMessage = "Queued to be sent again to the status pages that were not sent it in full. The pages already reached are not sent it again.";
+IncidentCreatedResend.skippedRefusalMessage = "Subscribers were never sent the notification that this incident was created (it was skipped), so there is nothing to send again.";
+IncidentCreatedResend.inFlightRefusalMessage = "The notification that this incident was created is queued or being sent right now. Wait until it has finished, then send it again.";
+IncidentCreatedResend.conflictingStatusMessage = "A request to send the incident-created notification to every status page again cannot also set its status. Leave the status out.";
+IncidentCreatedResend.noPermissionMessage = "You do not have permission to send the incident-created notification again. It needs the permission to edit incidents.";
+export default IncidentCreatedResend;
+//# sourceMappingURL=IncidentCreatedResend.js.map

package/build/dist/Types/StatusPage/IncidentCreatedResend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncidentCreatedResend.js","sourceRoot":"","sources":["../../../../Types/StatusPage/IncidentCreatedResend.ts"],"names":[],"mappings":"AACA,OAAO,sCAAsC,MAAM,0CAA0C,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAqB,qBAAqB;IA4BxC;;;;OAIG;IACI,MAAM,CAAC,WAAW,CACvB,aAA4C;QAE5C,IAAI,CAAC,aAAa,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;YACxD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,KAAK,GAAY,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEvD,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC;IAC5C,CAAC;IAEM,MAAM,CAAC,gBAAgB;QAC5B,OAAO;YACL,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI;SACzB,CAAC;IACJ,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,gBAAgB,CAC5B,MAAiE;QAEjE,QAAQ,MAAM,EAAE,CAAC;YACf,KAAK,sCAAsC,CAAC,OAAO,CAAC;YACpD,KAAK,sCAAsC,CAAC,MAAM;gBAChD,OAAO,IAAI,CAAC;YACd,KAAK,sCAAsC,CAAC,OAAO,CAAC;YACpD,KAAK,sCAAsC,CAAC,UAAU;gBACpD,OAAO,IAAI,CAAC,sBAAsB,CAAC;YACrC;gBACE,uEAAuE;gBACvE,OAAO,IAAI,CAAC,qBAAqB,CAAC;QACtC,CAAC;IACH,CAAC;;AApED,sEAAsE;AAC/C,iCAAW,GAChC,uCAAuC,CAAC;AAE1C,+DAA+D;AACxC,mCAAa,GAClC,oHAAoH,CAAC;AAEvH;;;GAGG;AACoB,wCAAkB,GACvC,6HAA6H,CAAC;AAEzG,2CAAqB,GAC1C,kIAAkI,CAAC;AAE9G,4CAAsB,GAC3C,oIAAoI,CAAC;AAEhH,8CAAwB,GAC7C,kIAAkI,CAAC;AAE9G,yCAAmB,GACxC,wHAAwH,CAAC;eA1BxG,qBAAqB"}

package/build/dist/Types/StatusPage/IncidentScopeAddedPagesNotification.js

@@ -0,0 +1,246 @@
+import StatusPageSubscriberNotificationStatus from "./StatusPageSubscriberNotificationStatus";
+/*
+ * An incident can be limited to some status pages (Incident.statusPages), and
+ * the pages it is limited to often change while it is open: a site turns out
+ * to be affected after all, or an incident a monitor created on its own gets
+ * scoped once someone works out who is affected. Subscribers of a page hear
+ * about an incident once, when it is created, so without a way back a page
+ * added later never got the 'created' notification at all.
+ *
+ * Whether a newly added page should hear about it now is the editor's call,
+ * so it is asked when pages are added (the dashboard ticks it by default)
+ * rather than decided automatically, and the answer travels with that update
+ * as a misc data prop - like SubscriberUpdateNotification and
+ * IncidentCreatedRenotify, it is not a column. IncidentService turns it into a
+ * Pending 'created' notification, and the Incident:SendNotificationToSubscribers
+ * job sends it to the pages in the scope that are not yet listed in
+ * Incident.statusPagesNotifiedOnCreation. That record is what keeps the pages
+ * that were already told from hearing it twice: the request re-queues the
+ * notification, and the record decides who it goes to.
+ *
+ * The record only exists once the job has settled a send, so two cases have
+ * none, and each is handled so that only the pages the edit adds are told:
+ *
+ * - the notification went out before the record existed (an incident from an
+ *   earlier release, Success or Failed with no record). It reached every page
+ *   that listed the incident's monitors back then, so there is no way to tell
+ *   an added page from one that was told, and nothing is queued. An empty
+ *   record would otherwise read as "nobody was told" and announce the incident
+ *   a second time;
+ * - the notification was Skipped and never sent (published without
+ *   announcing it, or declared without monitors). The pages the incident was
+ *   limited to before the edit were deliberately not told, so the update
+ *   writes them in as the record when it queues the notification (see
+ *   getRecordToSeedOnQueue): the job then tells the added pages only, not the
+ *   pages the editor chose not to announce it on.
+ *
+ * Everything here is shared by the dashboard, which offers the checkbox, and
+ * the server, which acts on it, so the two cannot drift apart: the dashboard
+ * offers the checkbox exactly when getAction would queue.
+ */
+// What an update that adds status pages does to the 'created' notification.
+export var IncidentScopeAddedPagesNotificationAction;
+(function (IncidentScopeAddedPagesNotificationAction) {
+    /*
+     * Nothing to do: no page was added, every added page was told already, or
+     * the incident is not to be announced.
+     */
+    IncidentScopeAddedPagesNotificationAction["None"] = "None";
+    // Put the 'created' notification back to Pending.
+    IncidentScopeAddedPagesNotificationAction["Queue"] = "Queue";
+    /*
+     * It is Pending, or being sent right now. A queued send reads the scope
+     * when it goes out, and a send that is running reads it again once it has
+     * finished and queues itself once more for any page added meanwhile, so the
+     * added pages are reached without any change here. IncidentService checks
+     * once the update is written, in case the send finished in between.
+     */
+    IncidentScopeAddedPagesNotificationAction["AlreadyQueued"] = "AlreadyQueued";
+})(IncidentScopeAddedPagesNotificationAction || (IncidentScopeAddedPagesNotificationAction = {}));
+class IncidentScopeAddedPagesNotification {
+    /*
+     * Only a real yes counts. The flag arrives over JSON, so accept the string
+     * form a hand-written API request might send, and nothing looser: a stray
+     * "false" or 1 must never email every subscriber of a status page.
+     */
+    static isRequested(miscDataProps) {
+        if (!miscDataProps || typeof miscDataProps !== "object") {
+            return false;
+        }
+        const value = miscDataProps[this.miscDataKey];
+        return value === true || value === "true";
+    }
+    static getMiscDataProps() {
+        return {
+            [this.miscDataKey]: true,
+        };
+    }
+    /*
+     * The status page ids in any shape a status page list arrives in - a model,
+     * a {_id} or {id} object, an ObjectID or a bare string - lower-cased (the
+     * database reads uuids back lower-cased) and without duplicates, in the
+     * order first seen.
+     */
+    static normalizeStatusPageIds(value) {
+        if (value === undefined || value === null) {
+            return [];
+        }
+        const entries = Array.isArray(value) ? value : [value];
+        const ids = [];
+        for (const entry of entries) {
+            const id = this.getStatusPageId(entry);
+            if (id && !ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+        return ids;
+    }
+    // Which pages a change of the scope from `before` to `after` adds and removes.
+    static getScopeChange(data) {
+        const before = this.normalizeStatusPageIds(data.before);
+        const after = this.normalizeStatusPageIds(data.after);
+        return {
+            addedStatusPageIds: after.filter((id) => {
+                return !before.includes(id);
+            }),
+            removedStatusPageIds: before.filter((id) => {
+                return !after.includes(id);
+            }),
+        };
+    }
+    /*
+     * The pages Incident.statusPagesNotifiedOnCreation lists, or null when there
+     * is no record: never written (the job has not settled a send since the
+     * record was introduced), or not a list.
+     */
+    static getRecordedStatusPageIds(value) {
+        if (!Array.isArray(value)) {
+            return null;
+        }
+        return this.normalizeStatusPageIds(value);
+    }
+    /*
+     * What adding `addedStatusPageIds` to an incident's scope does to its
+     * 'created' notification, given where that notification is:
+     *
+     * - no page added: nothing, whatever else the update does;
+     * - notifying on creation is off: nothing. An incident declared with
+     *   notifications off was deliberately kept quiet, and scoping it does not
+     *   change that;
+     * - hidden from status pages or private once the update is written:
+     *   nothing. The job would only skip it again. Publishing the incident
+     *   offers to announce it to the pages that were not told
+     *   (IncidentCreatedRenotify.canRenotifyOnPublish), including pages added
+     *   while it was hidden;
+     * - every added page is in the record: nothing, they were told already
+     *   (a page removed earlier and added back, or an unscoped incident being
+     *   narrowed to pages it reached);
+     * - Success or Failed with no record: nothing. It went out before the
+     *   record existed, to every page that listed the monitors then (see the
+     *   header);
+     * - Success, Skipped or Failed otherwise: queue it again. The job then
+     *   sends it to the pages in the scope it has no record of telling - the
+     *   added pages, plus, after a failure, the pages the failed send did not
+     *   reach;
+     * - Pending or InProgress: already on its way, and it reaches the added
+     *   pages (see AlreadyQueued).
+     */
+    static getAction(data) {
+        const addedStatusPageIds = this.normalizeStatusPageIds(data.addedStatusPageIds);
+        if (addedStatusPageIds.length === 0) {
+            return IncidentScopeAddedPagesNotificationAction.None;
+        }
+        const incident = data.incident;
+        if (incident.shouldStatusPageSubscribersBeNotifiedOnIncidentCreated !== true) {
+            return IncidentScopeAddedPagesNotificationAction.None;
+        }
+        // A null visibility is hidden to the job, so it is here too.
+        if (incident.isVisibleOnStatusPage !== true ||
+            incident.isPrivate === true) {
+            return IncidentScopeAddedPagesNotificationAction.None;
+        }
+        const status = incident.subscriberNotificationStatusOnIncidentCreated;
+        const recorded = this.getRecordedStatusPageIds(incident.statusPagesNotifiedOnCreation);
+        if (recorded === null) {
+            if (status === StatusPageSubscriberNotificationStatus.Success ||
+                status === StatusPageSubscriberNotificationStatus.Failed) {
+                return IncidentScopeAddedPagesNotificationAction.None;
+            }
+        }
+        else if (addedStatusPageIds.every((id) => {
+            return recorded.includes(id);
+        })) {
+            return IncidentScopeAddedPagesNotificationAction.None;
+        }
+        switch (status) {
+            case StatusPageSubscriberNotificationStatus.Pending:
+            case StatusPageSubscriberNotificationStatus.InProgress:
+                return IncidentScopeAddedPagesNotificationAction.AlreadyQueued;
+            default:
+                /*
+                 * Success, Skipped and Failed - and a missing status, which the
+                 * column's Pending default makes impossible but which would otherwise
+                 * never be sent.
+                 */
+                return IncidentScopeAddedPagesNotificationAction.Queue;
+        }
+    }
+    /*
+     * The record an update that queues the notification (action Queue) has to
+     * write along with it, or undefined when the stored record stands.
+     *
+     * With a record, the job already knows who was told. Without one the
+     * notification was never sent (getAction does not queue a Success or
+     * Failed one without a record), so the pages the incident was limited to
+     * before the update were deliberately not told - it was published without
+     * announcing it, or declared without monitors. They are written in as the
+     * record, so the job tells only the pages the update adds. An incident
+     * that was not limited to any page before has nothing to leave out: every
+     * page it is now limited to is one the update adds.
+     */
+    static getRecordToSeedOnQueue(data) {
+        if (this.getRecordedStatusPageIds(data.statusPagesNotifiedOnCreation)) {
+            return undefined;
+        }
+        return this.normalizeStatusPageIds(data.statusPageIdsBeforeUpdate);
+    }
+    static getStatusPageId(entry) {
+        if (!entry) {
+            return undefined;
+        }
+        let id = entry;
+        if (typeof entry === "object") {
+            const relation = entry;
+            // A model, an ObjectID, a {_id}/{id} object or a serialized ObjectID.
+            if (relation._id !== undefined && relation._id !== null) {
+                id = relation._id;
+            }
+            else if (relation.id !== undefined && relation.id !== null) {
+                id = relation.id;
+            }
+            else if (relation._type === "ObjectID" && relation.value) {
+                id = relation.value;
+            }
+        }
+        if (typeof id !== "string" && typeof id !== "object") {
+            return undefined;
+        }
+        const text = String(id).trim().toLowerCase();
+        if (!text || text === "[object object]") {
+            return undefined;
+        }
+        return text;
+    }
+}
+// The misc data prop an update request carries to ask for the notification.
+IncidentScopeAddedPagesNotification.miscDataKey = "notifyAddedStatusPagesOfIncidentCreated";
+IncidentScopeAddedPagesNotification.queuedMessage = "Status pages were added to this incident. Their subscribers will be sent the notification that this incident was created.";
+/*
+ * The status the job leaves when pages were added to the scope while it was
+ * sending: queued again, for the pages it had not reached.
+ */
+IncidentScopeAddedPagesNotification.addedWhileSendingMessage = "Status pages were added to this incident while its subscribers were being sent the notification that it was created. The added pages will be sent it next.";
+IncidentScopeAddedPagesNotification.formFieldTitle = "Send the incident-created notification to newly added pages";
+IncidentScopeAddedPagesNotification.formFieldDescription = "Subscribers of the status pages you add are sent the notification that this incident was created. Pages that were already told are not sent it again.";
+export default IncidentScopeAddedPagesNotification;
+//# sourceMappingURL=IncidentScopeAddedPagesNotification.js.map

package/build/dist/Types/StatusPage/IncidentScopeAddedPagesNotification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncidentScopeAddedPagesNotification.js","sourceRoot":"","sources":["../../../../Types/StatusPage/IncidentScopeAddedPagesNotification.ts"],"names":[],"mappings":"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"}

package/build/dist/Types/StatusPage/IncidentSubscriberAudience.js

@@ -0,0 +1,183 @@
+/*
+ * Who an incident's status page notifications reach, shown before anything is
+ * sent: on the last step of declaring an incident, and above a public note
+ * while it is being written. "Will notify: Site 03 (up to 41 email), Site 07
+ * (up to 18 email)".
+ *
+ * POST /incident/subscriber-audience (IncidentAPI) answers it, from the same
+ * helper the subscriber jobs send through (IncidentStatusPageScope), so the
+ * preview and the send cannot disagree about which pages an incident reaches.
+ * It takes either an incident that is being declared - the monitors and the
+ * status pages picked on the form - or one that exists.
+ *
+ * The counts are "up to": they count the confirmed subscribers of each page
+ * who have not unsubscribed, per channel. A subscriber who picked only some
+ * of a page's resources, or only some event types, is filtered out at send
+ * time; and for an incident limited to specific pages an email address or
+ * phone number on two of them gets one message, not two. Addresses themselves
+ * never leave the server - only counts do.
+ *
+ * Everything here is shared by the server, which builds the answer, and the
+ * dashboard, which reads it, so the two cannot drift apart.
+ */
+// Why a status page that lists the incident's monitors is not notified.
+export var IncidentSubscriberAudienceExclusionReason;
+(function (IncidentSubscriberAudienceExclusionReason) {
+    // The incident is limited to other status pages.
+    IncidentSubscriberAudienceExclusionReason["OutsideIncidentScope"] = "OutsideIncidentScope";
+    // The page only shows incidents limited to it, and this one is not.
+    IncidentSubscriberAudienceExclusionReason["OnlyShowsScopedIncidents"] = "OnlyShowsScopedIncidents";
+    // The page does not show incidents at all (Show Incidents is off).
+    IncidentSubscriberAudienceExclusionReason["HidesIncidents"] = "HidesIncidents";
+    /*
+     * Asked for a Retry of the incident's 'created' notification only: the
+     * page was already sent it in full (Incident.statusPagesNotifiedOnCreation),
+     * and Retry resumes after it.
+     */
+    IncidentSubscriberAudienceExclusionReason["AlreadyNotified"] = "AlreadyNotified";
+})(IncidentSubscriberAudienceExclusionReason || (IncidentSubscriberAudienceExclusionReason = {}));
+// The order channels are listed in, and what each is called on screen.
+export const INCIDENT_SUBSCRIBER_AUDIENCE_CHANNELS = [
+    { channel: "email", label: "email" },
+    { channel: "sms", label: "SMS" },
+    { channel: "slack", label: "Slack" },
+    { channel: "microsoftTeams", label: "Microsoft Teams" },
+    { channel: "webhook", label: "webhook" },
+];
+class IncidentSubscriberAudience {
+    static getEmptyCounts() {
+        return {
+            email: 0,
+            sms: 0,
+            slack: 0,
+            microsoftTeams: 0,
+            webhook: 0,
+        };
+    }
+    static getTotal(counts) {
+        return INCIDENT_SUBSCRIBER_AUDIENCE_CHANNELS.reduce((total, entry) => {
+            return total + (counts[entry.channel] || 0);
+        }, 0);
+    }
+    /*
+     * The channels of one page that reach anyone, in display order, with their
+     * counts: [{channel: "email", label: "email", count: 41}, ...].
+     */
+    static getNonEmptyChannels(counts) {
+        return INCIDENT_SUBSCRIBER_AUDIENCE_CHANNELS.map((entry) => {
+            return {
+                channel: entry.channel,
+                label: entry.label,
+                count: counts[entry.channel] || 0,
+            };
+        }).filter((entry) => {
+            return entry.count > 0;
+        });
+    }
+    // Whether anyone at all will be sent anything.
+    static reachesAnyone(audience) {
+        if (audience.isHiddenFromStatusPages || !audience.hasMonitors) {
+            return false;
+        }
+        return (audience.hiddenStatusPageCount > 0 ||
+            audience.statusPages.some((statusPage) => {
+                return this.getTotal(statusPage.subscriberCounts) > 0;
+            }));
+    }
+    /*
+     * The server's answer as the dashboard receives it. Read defensively: the
+     * summary is advisory, and a field that is missing or of the wrong type
+     * must read as "nothing" rather than break the form it sits on.
+     */
+    static fromJSON(json) {
+        const toArray = (value) => {
+            return Array.isArray(value)
+                ? value.filter((item) => {
+                    return Boolean(item) && typeof item === "object";
+                })
+                : [];
+        };
+        const toCount = (value) => {
+            const count = Number(value);
+            return Number.isFinite(count) && count > 0 ? Math.floor(count) : 0;
+        };
+        const toNamed = (item) => {
+            return {
+                statusPageId: String(item["statusPageId"] || ""),
+                name: String(item["name"] || ""),
+            };
+        };
+        const reasons = Object.values(IncidentSubscriberAudienceExclusionReason);
+        return {
+            hasMonitors: json["hasMonitors"] === true,
+            isScoped: json["isScoped"] === true,
+            isHiddenFromStatusPages: json["isHiddenFromStatusPages"] === true,
+            statusPages: toArray(json["statusPages"]).map((item) => {
+                return Object.assign(Object.assign({}, toNamed(item)), { subscriberCounts: this.countsFromJSON(item["subscriberCounts"]) });
+            }),
+            hiddenStatusPageCount: toCount(json["hiddenStatusPageCount"]),
+            excludedStatusPages: toArray(json["excludedStatusPages"])
+                .filter((item) => {
+                return reasons.includes(String(item["reason"]));
+            })
+                .map((item) => {
+                return Object.assign(Object.assign({}, toNamed(item)), { reason: item["reason"] });
+            }),
+            selectedStatusPagesNotListingMonitors: toArray(json["selectedStatusPagesNotListingMonitors"]).map(toNamed),
+        };
+    }
+    /*
+     * One page's counts as they arrive, each a whole number of at least 0: a
+     * count that is missing or not a number reads as 0.
+     */
+    static countsFromJSON(value) {
+        const counts = value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : {};
+        const toCount = (count) => {
+            const number = Number(count);
+            return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0;
+        };
+        return {
+            email: toCount(counts["email"]),
+            sms: toCount(counts["sms"]),
+            slack: toCount(counts["slack"]),
+            microsoftTeams: toCount(counts["microsoftTeams"]),
+            webhook: toCount(counts["webhook"]),
+        };
+    }
+    static toJSON(audience) {
+        return {
+            hasMonitors: audience.hasMonitors,
+            isScoped: audience.isScoped,
+            isHiddenFromStatusPages: audience.isHiddenFromStatusPages,
+            statusPages: audience.statusPages.map((statusPage) => {
+                return {
+                    statusPageId: statusPage.statusPageId,
+                    name: statusPage.name,
+                    subscriberCounts: Object.assign({}, statusPage.subscriberCounts),
+                };
+            }),
+            hiddenStatusPageCount: audience.hiddenStatusPageCount,
+            excludedStatusPages: audience.excludedStatusPages.map((statusPage) => {
+                return {
+                    statusPageId: statusPage.statusPageId,
+                    name: statusPage.name,
+                    reason: statusPage.reason,
+                };
+            }),
+            selectedStatusPagesNotListingMonitors: audience.selectedStatusPagesNotListingMonitors.map((statusPage) => {
+                return {
+                    statusPageId: statusPage.statusPageId,
+                    name: statusPage.name,
+                };
+            }),
+        };
+    }
+}
+// The route, under the API's base URL.
+IncidentSubscriberAudience.apiPath = "/incident/subscriber-audience";
+// How many monitors or status pages one request may name.
+IncidentSubscriberAudience.maxIdsPerRequest = 1000;
+export default IncidentSubscriberAudience;
+//# sourceMappingURL=IncidentSubscriberAudience.js.map