@oneuptime/common 14.0.6 → 14.0.8

package/build/dist/Types/SafeHtml.js

@@ -0,0 +1,84 @@
+/*
+ * A value that is ALREADY HTML and may go into an HTML document as written.
+ *
+ * Status page subscriber emails are filled from two kinds of value, and a
+ * plain string cannot say which one it holds:
+ *
+ *   - plain text: an incident, episode, maintenance or announcement title, a
+ *     severity or state name, a status page or resource name, a URL. Project
+ *     members type these, and a title is exactly what someone outside the
+ *     team gets to influence (an incident created from a monitor, an API
+ *     call, a Slack command). Put into HTML as written, a title such as
+ *     `<a href="https://evil.example">Reset your password</a>` becomes a live
+ *     link in an email the recipient trusts.
+ *   - HTML this code produced itself: Markdown.convertToHTML output (which
+ *     escapes the raw HTML an author typed and keeps only http, https and
+ *     mailto links), the date helper's multi-timezone HTML, and the resource
+ *     list StatusPageResourceUtil.getResourcesGroupedByGroupName builds from
+ *     escaped names.
+ *
+ * So the HTML ones travel wrapped in this type, and anything that is still a
+ * string is treated as plain text and escaped where it meets HTML (see
+ * SubscriberNotificationTemplateCompiler.compileEmailBodyTemplate). A value
+ * nobody thought about is therefore escaped, which at worst shows the reader
+ * an "&amp;" too many; it can never become markup by accident.
+ *
+ * Kept free of server dependencies so both the server and the dashboard can
+ * use it.
+ */
+var _a;
+/*
+ * Marks instances without instanceof, which a second copy of this module (a
+ * test's isolated module registry, a duplicated bundle) would defeat.
+ */
+const SAFE_HTML_BRAND = Symbol.for("OneUptime.SafeHtml");
+class SafeHtml {
+    constructor(html) {
+        // Read by isSafeHtml; a symbol key, so JSON.stringify leaves it out.
+        this[_a] = true;
+        this.html = html;
+    }
+    /*
+     * Wraps markup this code produced from values it had already made safe:
+     * Markdown.convertToHTML(..., MarkdownContentType.Email) output,
+     * OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones output, and
+     * StatusPageResourceUtil.getResourcesGroupedByGroupName output. Never a
+     * value a user typed.
+     */
+    static fromTrustedHtml(html) {
+        return new SafeHtml(html || "");
+    }
+    // Plain text, escaped so it reads the same in HTML.
+    static fromPlainText(text) {
+        return new SafeHtml(SafeHtml.escape(text || ""));
+    }
+    /*
+     * Escapes the five characters that can break out of HTML text or a quoted
+     * attribute value. The ampersand goes first, so the entities the other
+     * four become are not escaped a second time.
+     *
+     * This is the one implementation: Markdown.escapeHtml calls it.
+     */
+    static escape(text) {
+        return String(text)
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#39;");
+    }
+    static isSafeHtml(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            value[SAFE_HTML_BRAND] === true);
+    }
+    toHtml() {
+        return this.html;
+    }
+    toString() {
+        return this.html;
+    }
+}
+_a = SAFE_HTML_BRAND;
+export default SafeHtml;
+//# sourceMappingURL=SafeHtml.js.map

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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"}