@oneuptime/common 12.0.12 → 12.0.14

package/Types/API/Hostname.ts

@@ -182,6 +182,85 @@ export default class Hostname extends DatabaseProperty {
     return new Hostname(hostname);
   }
 
+  /*
+   * Splits a URL authority into its bare host and its port, using the same
+   * structure isValid() already understands: optional userinfo, then either
+   * a bracketed IPv6 literal, an unbracketed IPv6 literal, or a host with an
+   * optional ":port".
+   *
+   * fromString() is NOT a substitute. It splits on the FIRST colon, so it
+   * turns "[::1]:8080" into a host of "[" and a port of "", and any IPv6
+   * literal into nonsense. Callers that hold an authority (a URL's host
+   * component) and need the two parts apart must use this.
+   *
+   * Userinfo is dropped rather than preserved: the caller asked for a host
+   * to connect to, and credentials are not part of one. Anything that needs
+   * the original string still has the authority it passed in.
+   */
+  public static fromAuthority(authority: string): Hostname {
+    const trimmedAuthority: string = (authority || "").trim();
+
+    if (!trimmedAuthority) {
+      return new Hostname("");
+    }
+
+    /*
+     * Split on the LAST "@" for the same reason isValid() does: userinfo may
+     * itself contain an "@", and everything after the final one is the
+     * authority proper.
+     */
+    const atIndex: number = trimmedAuthority.lastIndexOf("@");
+    const hostAndPort: string =
+      atIndex === -1
+        ? trimmedAuthority
+        : trimmedAuthority.substring(atIndex + 1);
+
+    if (!hostAndPort) {
+      return new Hostname("");
+    }
+
+    // Bracketed IPv6, with or without a port: "[::1]", "[::1]:8080".
+    const bracketedIpv6Match: RegExpMatchArray | null = hostAndPort.match(
+      /^(\[[0-9a-fA-F:.]+\])(?::(\d{1,5}))?$/,
+    );
+
+    if (bracketedIpv6Match) {
+      const ipv6Host: string = bracketedIpv6Match[1] as string;
+      const ipv6Port: string | undefined = bracketedIpv6Match[2];
+
+      return ipv6Port
+        ? new Hostname(ipv6Host, ipv6Port)
+        : new Hostname(ipv6Host);
+    }
+
+    /*
+     * Unbracketed IPv6 literal: two or more colons cannot be a "host:port",
+     * so every colon belongs to the address itself and there is no port.
+     */
+    if ((hostAndPort.match(/:/g) || []).length > 1) {
+      return new Hostname(hostAndPort);
+    }
+
+    const colonIndex: number = hostAndPort.indexOf(":");
+
+    if (colonIndex === -1) {
+      return new Hostname(hostAndPort);
+    }
+
+    const host: string = hostAndPort.substring(0, colonIndex);
+    const port: string = hostAndPort.substring(colonIndex + 1);
+
+    /*
+     * A trailing colon with no digits ("host:") is not a port. Keep the host
+     * and drop the empty port rather than constructing an invalid Port.
+     */
+    if (!port) {
+      return new Hostname(host);
+    }
+
+    return new Hostname(host, port);
+  }
+
   public static override toDatabase(
     value: Hostname | FindOperator<Hostname>,
   ): string | null {

package/Types/Database/AccessControl/ColumnAccessControl.ts

@@ -30,20 +30,42 @@ type GetColumnAccessControlForAllColumnsFunction = <T extends BaseModel>(
   target: T,
 ) => Dictionary<ColumnAccessControl>;
 
+/*
+ * Per-class cache. Safe to key on the constructor because every decorated
+ * column is initialised to `undefined` in the class body, so Object.keys()
+ * is identical for every instance of a class (see OwnerOnlyColumn.ts).
+ * Callers must treat the returned dictionary as read-only.
+ */
+const accessControlCache: WeakMap<
+  { new (): BaseModel },
+  Dictionary<ColumnAccessControl>
+> = new WeakMap();
+
 export const getColumnAccessControlForAllColumns: GetColumnAccessControlForAllColumnsFunction =
   <T extends BaseModel>(target: T): Dictionary<ColumnAccessControl> => {
-    const dictonary: Dictionary<ColumnAccessControl> = {};
-    const keys: Array<string> = Object.keys(target);
-
-    for (const key of keys) {
-      if (Reflect.getMetadata(accessControlSymbol, target, key)) {
-        dictonary[key] = Reflect.getMetadata(
-          accessControlSymbol,
-          target,
-          key,
-        ) as ColumnAccessControl;
+    const modelClass: { new (): BaseModel } = target.constructor as {
+      new (): BaseModel;
+    };
+    let cached: Dictionary<ColumnAccessControl> | undefined =
+      accessControlCache.get(modelClass);
+
+    if (!cached) {
+      const dictonary: Dictionary<ColumnAccessControl> = {};
+      const keys: Array<string> = Object.keys(target);
+
+      for (const key of keys) {
+        const accessControl: ColumnAccessControl | undefined =
+          Reflect.getMetadata(accessControlSymbol, target, key) as
+            | ColumnAccessControl
+            | undefined;
+        if (accessControl) {
+          dictonary[key] = accessControl;
+        }
       }
+
+      cached = dictonary;
+      accessControlCache.set(modelClass, cached);
     }
 
-    return dictonary;
+    return cached;
   };

package/Types/Database/AccessControl/ColumnBillingAccessControl.ts

@@ -30,20 +30,42 @@ type GetColumnBillingAccessControlForAllColumnsFunction = <T extends BaseModel>(
   target: T,
 ) => Dictionary<ColumnBillingAccessControl>;
 
+/*
+ * Per-class cache. Safe to key on the constructor because every decorated
+ * column is initialised to `undefined` in the class body, so Object.keys()
+ * is identical for every instance of a class (see OwnerOnlyColumn.ts).
+ * Callers must treat the returned dictionary as read-only.
+ */
+const billingAccessControlCache: WeakMap<
+  { new (): BaseModel },
+  Dictionary<ColumnBillingAccessControl>
+> = new WeakMap();
+
 export const getColumnBillingAccessControlForAllColumns: GetColumnBillingAccessControlForAllColumnsFunction =
   <T extends BaseModel>(target: T): Dictionary<ColumnBillingAccessControl> => {
-    const dictonary: Dictionary<ColumnBillingAccessControl> = {};
-    const keys: Array<string> = Object.keys(target);
-
-    for (const key of keys) {
-      if (Reflect.getMetadata(accessControlSymbol, target, key)) {
-        dictonary[key] = Reflect.getMetadata(
-          accessControlSymbol,
-          target,
-          key,
-        ) as ColumnBillingAccessControl;
+    const modelClass: { new (): BaseModel } = target.constructor as {
+      new (): BaseModel;
+    };
+    let cached: Dictionary<ColumnBillingAccessControl> | undefined =
+      billingAccessControlCache.get(modelClass);
+
+    if (!cached) {
+      const dictonary: Dictionary<ColumnBillingAccessControl> = {};
+      const keys: Array<string> = Object.keys(target);
+
+      for (const key of keys) {
+        const accessControl: ColumnBillingAccessControl | undefined =
+          Reflect.getMetadata(accessControlSymbol, target, key) as
+            | ColumnBillingAccessControl
+            | undefined;
+        if (accessControl) {
+          dictonary[key] = accessControl;
+        }
       }
+
+      cached = dictonary;
+      billingAccessControlCache.set(modelClass, cached);
     }
 
-    return dictonary;
+    return cached;
   };

package/Types/Database/DatabaseProperty.ts

@@ -39,6 +39,44 @@ export default class DatabaseProperty extends SerializableObject {
       return value as any;
     }
 
+    /*
+     * A FindOperator reaches a transformer when the query value is an
+     * operator rather than a plain value. Two ways in:
+     *
+     *   - Nested. `And(Equal(id), Raw(privacyClause))` — the shape every
+     *     privacy/scope filter builds (Server/Utils/PrivacyFilterUtil.ts).
+     *     TypeORM calls `operator.transformValue(column.transformer)`
+     *     (SelectQueryBuilder.buildWhere), and FindOperator.transformValue
+     *     hands each CHILD OPERATOR to this function whenever the operator
+     *     carries multiple parameters — which And() and Or() both do.
+     *   - Top level. ColumnMetadata.getEntityValue applies the transformer to
+     *     the whole criteria of a .where()/.update()/.delete() call.
+     *
+     * Every toDatabase() below expects a value, so an operator makes it
+     * produce garbage: "[object Object]" from the string-ish types (ObjectID
+     * included — a uuid column then fails with Postgres 22P02 invalid input
+     * syntax for type uuid), `null` from Port, a serialized operator from the
+     * JSON types. The child is REPLACED by that garbage, so the caller's own
+     * predicate is lost and the privacy clause it was ANDed with can no
+     * longer match anything.
+     *
+     * Transform the operator's leaf value(s) in place and hand the operator
+     * back, so `And`/`Or`/`In`/`Not`/`Between` keep their structure and only
+     * the leaves are converted. Recursion terminates because transformValue
+     * always descends into the operator's value, and a leaf is never a
+     * FindOperator.
+     *
+     * NOTE: transformValue mutates. One query object can legitimately be
+     * transformed more than once — BaseAPI.getList shares it between findBy
+     * and countBy — so every toDatabase() has to be a fixpoint: handed its
+     * own output it must return that output unchanged. Tests/Types/Database/
+     * DatabasePropertyFindOperator.test.ts enforces that for each type.
+     */
+    if (value instanceof FindOperator) {
+      value.transformValue(this.getDatabaseTransformer());
+      return value as any;
+    }
+
     return this.toDatabase(value);
   }
 

package/Types/Database/TableColumn.ts

@@ -63,21 +63,48 @@ type GetTableColumnsFunction = <T extends BaseModel>(
   target: T,
 ) => Dictionary<TableColumnMetadata>;
 
+/*
+ * Per-class cache. Safe to key on the constructor because every decorated
+ * column is initialised to `undefined` in the class body, so Object.keys()
+ * is identical for every instance of a class (see OwnerOnlyColumn.ts).
+ */
+const tableColumnsCache: WeakMap<
+  { new (): BaseModel },
+  Dictionary<TableColumnMetadata>
+> = new WeakMap();
+
 export const getTableColumns: GetTableColumnsFunction = <T extends BaseModel>(
   target: T,
 ): Dictionary<TableColumnMetadata> => {
-  const dictonary: Dictionary<TableColumnMetadata> = {};
-  const keys: Array<string> = Object.keys(target);
+  const modelClass: { new (): BaseModel } = target.constructor as {
+    new (): BaseModel;
+  };
+  let cached: Dictionary<TableColumnMetadata> | undefined =
+    tableColumnsCache.get(modelClass);
+
+  if (!cached) {
+    const dictonary: Dictionary<TableColumnMetadata> = {};
+    const keys: Array<string> = Object.keys(target);
 
-  for (const key of keys) {
-    if (Reflect.getMetadata(tableColumn, target, key)) {
-      dictonary[key] = Reflect.getMetadata(
+    for (const key of keys) {
+      const metadata: TableColumnMetadata | undefined = Reflect.getMetadata(
         tableColumn,
         target,
         key,
-      ) as TableColumnMetadata;
+      ) as TableColumnMetadata | undefined;
+      if (metadata) {
+        dictonary[key] = metadata;
+      }
     }
+
+    cached = dictonary;
+    tableColumnsCache.set(modelClass, cached);
   }
 
-  return dictonary;
+  /*
+   * Hand out a copy, not the cached dictionary itself: callers mutate the
+   * result (the API reference docs delete entries from it), which would
+   * otherwise strip columns from every later call for the same class.
+   */
+  return { ...cached };
 };

package/Types/Email/EmailTemplateType.ts

@@ -3,6 +3,7 @@ enum EmailTemplateType {
   ForgotPassword = "ForgotPassword.hbs",
   ProbeOffline = "ProbeOffline.hbs",
   SignupWelcomeEmail = "SignupWelcomeEmail.hbs",
+  CompleteRegistration = "CompleteRegistration.hbs",
   ProbeConnectionStatusChange = "ProbeConnectionStatusChange.hbs",
   AIAgentConnectionStatusChange = "AIAgentConnectionStatusChange.hbs",
   AIAgentOwnerAdded = "AIAgentOwnerAdded.hbs",

package/Types/Events/Recurring.ts

@@ -313,7 +313,22 @@ export default class Recurring extends DatabaseProperty {
     value: Recurring | Array<Recurring> | FindOperator<Recurring>,
   ): JSONObject | Array<JSONObject> | null {
     if (Array.isArray(value)) {
-      return this.toJSONArray(value as Array<Recurring>);
+      /*
+       * Per item rather than through toJSONArray, which assumes every item is
+       * still a Recurring instance and throws "item.toJSON is not a function"
+       * on an already-serialized array. TypeORM can hand a transformer its own
+       * output — BaseAPI.getList shares one query object between findBy and
+       * countBy — so this has to be a fixpoint.
+       */
+      return (value as Array<Recurring | JSONObject>).map(
+        (item: Recurring | JSONObject) => {
+          if (item instanceof Recurring) {
+            return item.toJSON();
+          }
+
+          return JSONFunctions.serialize(item as JSONObject);
+        },
+      );
     }
 
     if (value && value instanceof Recurring) {

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -44,6 +44,19 @@ export interface MonitorCriteriaInstanceType {
 }
 
 export default class MonitorCriteriaInstance extends DatabaseProperty {
+  /*
+   * Keyword the out-of-the-box criteria for the two incoming monitor types
+   * (Incoming Request and Incoming Email) look for in the payload body.
+   *
+   * These monitors are driven by whatever the sender pushes, so the default
+   * that is useful to the most people is "the sender told us something broke":
+   * a body carrying this keyword takes the monitor offline and opens an
+   * incident, a body without it puts the monitor back online. Users who want
+   * a dead-man's-switch instead can still add an Incoming Request /
+   * Email Received criteria by hand.
+   */
+  public static readonly DEFAULT_INCOMING_BODY_ERROR_KEYWORD: string = "error";
+
   public data: MonitorCriteriaInstanceType | undefined = undefined;
 
   public constructor() {
@@ -88,9 +101,9 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         filterCondition: FilterCondition.All,
         filters: [
           {
-            checkOn: CheckOn.IncomingRequest,
-            filterType: FilterType.RecievedInMinutes,
-            value: 30,
+            checkOn: CheckOn.RequestBody,
+            filterType: FilterType.NotContains,
+            value: MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD,
           },
         ],
         incidents: [],
@@ -99,7 +112,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         changeMonitorStatus: true,
         createIncidents: false,
         name: `Check if ${arg.monitorName} is online`,
-        description: `This criteria checks if the ${arg.monitorName} is online`,
+        description: `This criteria checks if the request body of ${arg.monitorName} does not contain "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}"`,
       };
 
       return monitorCriteriaInstance;
@@ -115,9 +128,9 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         filterCondition: FilterCondition.All,
         filters: [
           {
-            checkOn: CheckOn.EmailReceivedAt,
-            filterType: FilterType.RecievedInMinutes,
-            value: 30,
+            checkOn: CheckOn.EmailBody,
+            filterType: FilterType.NotContains,
+            value: MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD,
           },
         ],
         incidents: [],
@@ -126,7 +139,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         changeMonitorStatus: true,
         createIncidents: false,
         name: `Check if ${arg.monitorName} is online`,
-        description: `This criteria checks if the ${arg.monitorName} is online`,
+        description: `This criteria checks if the email body of ${arg.monitorName} does not contain "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}"`,
       };
 
       return monitorCriteriaInstance;
@@ -1198,15 +1211,19 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         filterCondition: FilterCondition.Any,
         filters: [
           {
-            checkOn: CheckOn.IncomingRequest,
-            filterType: FilterType.NotRecievedInMinutes,
-            value: 30, // if the request is not recieved in 30 minutes, then the monitor is offline
+            /*
+             * If the sender reports an error in the request body, the monitor
+             * is offline.
+             */
+            checkOn: CheckOn.RequestBody,
+            filterType: FilterType.Contains,
+            value: MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD,
           },
         ],
         alerts: [
           {
             title: `${arg.monitorName} is offline`,
-            description: `${arg.monitorName} is currently offline.`,
+            description: `${arg.monitorName} is currently offline. The request body contains "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}".`,
             alertSeverityId: arg.alertSeverityId,
             autoResolveAlert: true,
             id: ObjectID.generate().toString(),
@@ -1217,7 +1234,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         incidents: [
           {
             title: `${arg.monitorName} is offline`,
-            description: `${arg.monitorName} is currently offline.`,
+            description: `${arg.monitorName} is currently offline. The request body contains "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}".`,
             incidentSeverityId: arg.incidentSeverityId,
             autoResolveIncident: true,
             id: ObjectID.generate().toString(),
@@ -1227,7 +1244,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         changeMonitorStatus: true,
         createIncidents: true,
         name: `Check if ${arg.monitorName} is offline`,
-        description: `This criteria checks if the ${arg.monitorName} is offline`,
+        description: `This criteria checks if the request body of ${arg.monitorName} contains "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}"`,
       };
     }
 
@@ -1238,15 +1255,19 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         filterCondition: FilterCondition.Any,
         filters: [
           {
-            checkOn: CheckOn.EmailReceivedAt,
-            filterType: FilterType.NotRecievedInMinutes,
-            value: 30, // if email is not received in 30 minutes, then the monitor is offline
+            /*
+             * If the received email reports an error in its body, the monitor
+             * is offline.
+             */
+            checkOn: CheckOn.EmailBody,
+            filterType: FilterType.Contains,
+            value: MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD,
           },
         ],
         alerts: [
           {
             title: `${arg.monitorName} is offline`,
-            description: `${arg.monitorName} is currently offline. No email received.`,
+            description: `${arg.monitorName} is currently offline. The email body contains "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}".`,
             alertSeverityId: arg.alertSeverityId,
             autoResolveAlert: true,
             id: ObjectID.generate().toString(),
@@ -1257,7 +1278,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         incidents: [
           {
             title: `${arg.monitorName} is offline`,
-            description: `${arg.monitorName} is currently offline. No email received.`,
+            description: `${arg.monitorName} is currently offline. The email body contains "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}".`,
             incidentSeverityId: arg.incidentSeverityId,
             autoResolveIncident: true,
             id: ObjectID.generate().toString(),
@@ -1267,7 +1288,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         changeMonitorStatus: true,
         createIncidents: true,
         name: `Check if ${arg.monitorName} is offline`,
-        description: `This criteria checks if the ${arg.monitorName} is offline`,
+        description: `This criteria checks if the email body of ${arg.monitorName} contains "${MonitorCriteriaInstance.DEFAULT_INCOMING_BODY_ERROR_KEYWORD}"`,
       };
     }
 

package/Types/Monitor/MonitorStep.ts

@@ -1156,8 +1156,20 @@ export default class MonitorStep extends DatabaseProperty {
             ),
           )
         : undefined,
+      /*
+       * Normalized for the same reason domainMonitor above is: a config
+       * authored through the API or a template need not carry `resolvers`,
+       * and the probe iterates that list without a guard. A raw passthrough
+       * therefore threw a TypeError inside the probe BEFORE it posted any
+       * result, so the monitor produced nothing at all - no check, no
+       * status change, no error the user could see.
+       */
       dnssecMonitor: json["dnssecMonitor"]
-        ? (json["dnssecMonitor"] as JSONObject)
+        ? MonitorStepDnssecMonitorUtil.toJSON(
+            MonitorStepDnssecMonitorUtil.fromJSON(
+              json["dnssecMonitor"] as JSONObject,
+            ),
+          )
         : undefined,
       sqlMonitor: json["sqlMonitor"]
         ? (json["sqlMonitor"] as JSONObject)