@oneuptime/common 12.0.4 → 12.0.6

package/Types/DataSource/DataSourceType.ts

@@ -0,0 +1,213 @@
+/*
+ * External systems a project-level Data Source can connect to. Dashboards
+ * bind widgets to a Data Source + a query written in that source's native
+ * query language (PromQL, SQL, LogQL, ES Query DSL, or a REST request
+ * descriptor), and the server-side connector for the type normalizes the
+ * response into the same shapes OneUptime's own widgets already consume.
+ */
+enum DataSourceType {
+  Prometheus = "Prometheus",
+  PostgreSQL = "PostgreSQL",
+  MySQL = "MySQL",
+  MicrosoftSqlServer = "Microsoft SQL Server",
+  ClickHouse = "ClickHouse",
+  Loki = "Loki",
+  Elasticsearch = "Elasticsearch",
+  RestApi = "REST API",
+}
+
+export default DataSourceType;
+
+/*
+ * What a type is used for, so the type picker can group hundreds of
+ * connectors into a handful of sections. Enum values are the section
+ * headings; DataSourceTypeCategories below fixes the display order.
+ */
+export enum DataSourceTypeCategory {
+  Metrics = "Metrics",
+  Logs = "Logs",
+  Databases = "Databases",
+  Search = "Search",
+  Api = "APIs",
+}
+
+export const DataSourceTypeCategories: Array<DataSourceTypeCategory> = [
+  DataSourceTypeCategory.Metrics,
+  DataSourceTypeCategory.Logs,
+  DataSourceTypeCategory.Databases,
+  DataSourceTypeCategory.Search,
+  DataSourceTypeCategory.Api,
+];
+
+export interface DataSourceTypeProps {
+  dataSourceType: DataSourceType;
+  title: string;
+  description: string;
+  category: DataSourceTypeCategory;
+  queryLanguageTitle: string;
+  queryPlaceholder: string;
+}
+
+export class DataSourceTypeUtil {
+  public static getAllDataSourceTypes(): Array<DataSourceType> {
+    return [
+      DataSourceType.Prometheus,
+      DataSourceType.PostgreSQL,
+      DataSourceType.MySQL,
+      DataSourceType.MicrosoftSqlServer,
+      DataSourceType.ClickHouse,
+      DataSourceType.Loki,
+      DataSourceType.Elasticsearch,
+      DataSourceType.RestApi,
+    ];
+  }
+
+  /*
+   * Sources reached over HTTP(S) at a base URL (Prometheus-compatible APIs,
+   * Loki, Elasticsearch, arbitrary REST endpoints). These require `url` on
+   * the Data Source and are queried through the SSRF-guarded HTTP client.
+   */
+  public static isHttpBasedType(dataSourceType: DataSourceType): boolean {
+    return [
+      DataSourceType.Prometheus,
+      DataSourceType.Loki,
+      DataSourceType.Elasticsearch,
+      DataSourceType.RestApi,
+    ].includes(dataSourceType);
+  }
+
+  /*
+   * Sources reached with a database driver over host/port. These require
+   * `databaseHost` (+ optionally port/databaseName/username/password) and
+   * run read-only guarded SQL.
+   */
+  public static isDatabaseType(dataSourceType: DataSourceType): boolean {
+    return [
+      DataSourceType.PostgreSQL,
+      DataSourceType.MySQL,
+      DataSourceType.MicrosoftSqlServer,
+      DataSourceType.ClickHouse,
+    ].includes(dataSourceType);
+  }
+
+  public static getCategory(
+    dataSourceType: DataSourceType,
+  ): DataSourceTypeCategory {
+    return DataSourceTypeUtil.getProps(dataSourceType).category;
+  }
+
+  /** Default port used to seed the settings form for database sources. */
+  public static getDefaultPort(dataSourceType: DataSourceType): number | null {
+    switch (dataSourceType) {
+      case DataSourceType.PostgreSQL:
+        return 5432;
+      case DataSourceType.MySQL:
+        return 3306;
+      case DataSourceType.MicrosoftSqlServer:
+        return 1433;
+      case DataSourceType.ClickHouse:
+        return 8123; // HTTP interface — the @clickhouse/client transport.
+      default:
+        return null;
+    }
+  }
+
+  public static getProps(dataSourceType: DataSourceType): DataSourceTypeProps {
+    switch (dataSourceType) {
+      case DataSourceType.Prometheus:
+        return {
+          dataSourceType,
+          title: "Prometheus",
+          description:
+            "Query a Prometheus-compatible API (Prometheus, Thanos, Cortex, Mimir, VictoriaMetrics) with PromQL.",
+          category: DataSourceTypeCategory.Metrics,
+          queryLanguageTitle: "PromQL",
+          queryPlaceholder: 'rate(http_requests_total{job="api"}[5m])',
+        };
+      case DataSourceType.PostgreSQL:
+        return {
+          dataSourceType,
+          title: "PostgreSQL",
+          description:
+            "Run read-only SQL against a PostgreSQL-compatible database (PostgreSQL, TimescaleDB, CockroachDB).",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "SQL",
+          queryPlaceholder:
+            "SELECT created_at AS time, COUNT(*) AS value FROM orders WHERE created_at BETWEEN $__startTime AND $__endTime GROUP BY 1 ORDER BY 1",
+        };
+      case DataSourceType.MySQL:
+        return {
+          dataSourceType,
+          title: "MySQL",
+          description: "Run read-only SQL against a MySQL or MariaDB database.",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "SQL",
+          queryPlaceholder:
+            "SELECT created_at AS time, COUNT(*) AS value FROM orders WHERE created_at BETWEEN $__startTime AND $__endTime GROUP BY 1 ORDER BY 1",
+        };
+      case DataSourceType.MicrosoftSqlServer:
+        return {
+          dataSourceType,
+          title: "Microsoft SQL Server",
+          description:
+            "Run read-only SQL against a Microsoft SQL Server or Azure SQL database.",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "T-SQL",
+          queryPlaceholder:
+            "SELECT created_at AS time, COUNT(*) AS value FROM orders WHERE created_at BETWEEN $__startTime AND $__endTime GROUP BY created_at ORDER BY created_at",
+        };
+      case DataSourceType.ClickHouse:
+        return {
+          dataSourceType,
+          title: "ClickHouse",
+          description:
+            "Run read-only SQL against a ClickHouse database over its HTTP interface.",
+          category: DataSourceTypeCategory.Databases,
+          queryLanguageTitle: "SQL",
+          queryPlaceholder:
+            "SELECT toStartOfMinute(timestamp) AS time, count() AS value FROM events WHERE timestamp BETWEEN $__startTime AND $__endTime GROUP BY time ORDER BY time",
+        };
+      case DataSourceType.Loki:
+        return {
+          dataSourceType,
+          title: "Grafana Loki",
+          description:
+            "Query a Grafana Loki log aggregation endpoint with LogQL metric queries.",
+          category: DataSourceTypeCategory.Logs,
+          queryLanguageTitle: "LogQL",
+          queryPlaceholder: 'sum(rate({app="api"} |= "error" [5m]))',
+        };
+      case DataSourceType.Elasticsearch:
+        return {
+          dataSourceType,
+          title: "Elasticsearch",
+          description:
+            "Query an Elasticsearch or OpenSearch cluster with Query DSL (date-histogram aggregations for charts).",
+          category: DataSourceTypeCategory.Search,
+          queryLanguageTitle: "Query DSL (JSON)",
+          queryPlaceholder:
+            '{ "query": { "match_all": {} }, "aggs": { "over_time": { "date_histogram": { "field": "@timestamp", "fixed_interval": "1m" }, "aggs": { "value": { "value_count": { "field": "_id" } } } } } }',
+        };
+      case DataSourceType.RestApi:
+        return {
+          dataSourceType,
+          title: "REST API",
+          description:
+            "Fetch JSON from any HTTP(S) API and map fields into time series or tables.",
+          category: DataSourceTypeCategory.Api,
+          queryLanguageTitle: "Request (JSON)",
+          queryPlaceholder:
+            '{ "path": "/api/stats", "method": "GET", "rowsPath": "data.items", "timestampField": "time", "valueField": "count" }',
+        };
+      default:
+        return {
+          dataSourceType,
+          title: dataSourceType,
+          description: "",
+          category: DataSourceTypeCategory.Api,
+          queryLanguageTitle: "Query",
+          queryPlaceholder: "",
+        };
+    }
+  }
+}

package/Types/Date.ts

@@ -476,7 +476,12 @@ export default class OneUptimeDate {
   }
 
   public static getCurrentDate(): Date {
-    return moment().toDate();
+    /*
+     * Not moment().toDate(): this is called on per-record telemetry ingest
+     * paths, and a moment wrapper allocation per call is pure overhead for
+     * what is exactly `new Date()`.
+     */
+    return new Date();
   }
 
   public static fromNow(date: Date): string {
@@ -934,6 +939,17 @@ export default class OneUptimeDate {
     return this.getSecondsInDays(days) * 1000;
   }
 
+  public static getSecondsInHours(hours: PositiveNumber | number): number {
+    if (!(hours instanceof PositiveNumber)) {
+      hours = new PositiveNumber(hours);
+    }
+    return hours.positiveNumber * 60 * 60;
+  }
+
+  public static getMillisecondsInHours(hours: PositiveNumber | number): number {
+    return this.getSecondsInHours(hours) * 1000;
+  }
+
   public static getSomeHoursAgo(hours: PositiveNumber | number): Date {
     if (!(hours instanceof PositiveNumber)) {
       hours = new PositiveNumber(hours);
@@ -2067,9 +2083,33 @@ export default class OneUptimeDate {
     return date;
   }
 
+  /*
+   * Hand-rolled UTC "YYYY-MM-DD HH:mm:ss" formatter. The two Clickhouse
+   * formatters below run several times per ingested log / span / metric
+   * datapoint — millions of calls per minute on a busy worker — and a
+   * moment() wrapper plus format-token parsing per call is roughly an order
+   * of magnitude more expensive than reading the UTC fields directly.
+   * Output is byte-identical to moment's, including the "Invalid date"
+   * sentinel for NaN dates.
+   */
+  private static formatUtcClickhouseDateTime(date: Date): string {
+    if (Number.isNaN(date.getTime())) {
+      return "Invalid date";
+    }
+
+    const year: string = String(date.getUTCFullYear()).padStart(4, "0");
+    const month: string = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day: string = String(date.getUTCDate()).padStart(2, "0");
+    const hours: string = String(date.getUTCHours()).padStart(2, "0");
+    const minutes: string = String(date.getUTCMinutes()).padStart(2, "0");
+    const seconds: string = String(date.getUTCSeconds()).padStart(2, "0");
+
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+  }
+
   public static toClickhouseDateTime(date: Date | string): string {
     const parsedDate: Date = this.fromString(date);
-    return moment(parsedDate).utc().format("YYYY-MM-DD HH:mm:ss");
+    return this.formatUtcClickhouseDateTime(parsedDate);
   }
 
   public static toClickhouseDateTime64(
@@ -2077,7 +2117,7 @@ export default class OneUptimeDate {
     nanoTimestamp?: number,
   ): string {
     const parsedDate: Date = this.fromString(date);
-    const base: string = moment(parsedDate).utc().format("YYYY-MM-DD HH:mm:ss");
+    const base: string = this.formatUtcClickhouseDateTime(parsedDate);
 
     let nanoFraction: string;
 

package/Types/HashedString.ts

@@ -24,9 +24,10 @@ import { FindOperator } from "typeorm";
  *   salted    `SHA256("v2:" + salt + ":" + secret + ":" + value)`.
  *
  * Neither records its scheme in the digest — it is a bare hex SHA-256 either
- * way — so they are told apart by whether the row carries a salt. The "v2"
- * prefix and the separators exist for domain separation: without them a
- * crafted salt could make a salted input collide with an unsalted one.
+ * way — so callers normally select the scheme by whether the row carries a
+ * salt. PasswordHash also has a bare-hash fallback for rolling deployments,
+ * where an old pod can write the original scheme while leaving a newer salt
+ * behind. The "v2" prefix and separators exist for domain separation.
  */
 const SALTED_HASH_SCHEME_VERSION: string = "v2";
 

package/Types/Monitor/CriteriaFilter.ts

@@ -5,6 +5,8 @@ export enum CheckOn {
   ResponseTime = "Response Time (in ms)",
   PacketLossPercent = "Packet Loss (in %)",
   Jitter = "Jitter (in ms)",
+  PortDnsLookupTime = "Port DNS Lookup Time (in ms)",
+  PortTcpConnectTime = "Port TCP Connect Time (in ms)",
   ResponseStatusCode = "Response Status Code",
   ResponseHeader = "Response Header",
   ResponseHeaderValue = "Response Header Value",
@@ -399,6 +401,8 @@ export class CriteriaFilterUtil {
       checkOn === CheckOn.ResponseTime ||
       checkOn === CheckOn.PacketLossPercent ||
       checkOn === CheckOn.Jitter ||
+      checkOn === CheckOn.PortDnsLookupTime ||
+      checkOn === CheckOn.PortTcpConnectTime ||
       checkOn === CheckOn.DiskUsagePercent ||
       checkOn === CheckOn.CPUUsagePercent ||
       checkOn === CheckOn.MemoryUsagePercent ||

package/Types/Monitor/DomainMonitor/DomainLookupMethod.ts

@@ -0,0 +1,23 @@
+/*
+ * Which protocol the probe uses to read a domain's registration record.
+ *
+ * WHOIS is the legacy protocol and its server list is not authoritative:
+ * clients ship a static map of TLD -> WHOIS host, and registries move. Every
+ * Identity Digital TLD (.digital, .email, .life, .today, .zone, ~290 more)
+ * still points at the retired whois.donuts.co in most of those maps, and that
+ * host now answers every query with the literal text "TLD is not supported."
+ * instead of a record. RDAP (RFC 9083) is the ICANN-mandated replacement and
+ * is discovered from the IANA bootstrap registry (RFC 9224), so it stays
+ * correct as registries move.
+ *
+ * Plenty of ccTLDs (.io, .co, .de, .ch, .jp, ...) publish no RDAP service at
+ * all, which is why Auto - RDAP when the TLD has one, WHOIS otherwise - is
+ * the default rather than RDAP.
+ */
+enum DomainLookupMethod {
+  Auto = "Auto",
+  RDAP = "RDAP",
+  WHOIS = "WHOIS",
+}
+
+export default DomainLookupMethod;

package/Types/Monitor/DomainMonitor/DomainMonitorResponse.ts

@@ -1,4 +1,5 @@
 import ProbeAttempt from "../../Probe/ProbeAttempt";
+import DomainLookupMethod from "./DomainLookupMethod";
 
 export default interface DomainMonitorResponse {
   isOnline: boolean;
@@ -16,4 +17,10 @@ export default interface DomainMonitorResponse {
   isTimeout?: boolean | undefined;
   probeAttempts?: Array<ProbeAttempt> | undefined;
   totalAttempts?: number | undefined;
+  /*
+   * Which protocol actually produced this record. With the Auto lookup
+   * method the answer varies by TLD, so it is worth surfacing rather than
+   * leaving the operator to guess.
+   */
+  lookupMethod?: DomainLookupMethod | undefined;
 }

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -505,6 +505,12 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         monitorStatusId: arg.monitorStatusId,
         filterCondition: FilterCondition.All,
         filters: [
+          // The registration lookup itself has to have worked.
+          {
+            checkOn: CheckOn.IsOnline,
+            filterType: FilterType.True,
+            value: undefined,
+          },
           {
             checkOn: CheckOn.DomainIsExpired,
             filterType: FilterType.False,
@@ -517,7 +523,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         changeMonitorStatus: true,
         createIncidents: false,
         name: `Check if ${arg.monitorName} is not expired`,
-        description: `This criteria checks if the ${arg.monitorName} domain registration is not expired`,
+        description: `This criteria checks if the ${arg.monitorName} domain registration was read successfully and is not expired`,
       };
 
       return monitorCriteriaInstance;
@@ -774,11 +780,22 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
             filterType: FilterType.True,
             value: undefined,
           },
+          /*
+           * Without this, a lookup that returns no registration data at all
+           * leaves every Domain* filter unable to decide, and the monitor
+           * keeps whatever status it had - so a domain whose registration
+           * data cannot be read looks exactly like a healthy one.
+           */
+          {
+            checkOn: CheckOn.IsOnline,
+            filterType: FilterType.False,
+            value: undefined,
+          },
         ],
         incidents: [
           {
-            title: `${arg.monitorName} domain is expired`,
-            description: `${arg.monitorName} domain registration has expired.`,
+            title: `${arg.monitorName} domain check failed`,
+            description: `${arg.monitorName} domain registration has expired, or its registration data could not be retrieved.`,
             incidentSeverityId: arg.incidentSeverityId,
             autoResolveIncident: true,
             id: ObjectID.generate().toString(),
@@ -790,16 +807,16 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         createAlerts: false,
         alerts: [
           {
-            title: `${arg.monitorName} domain is expired`,
-            description: `${arg.monitorName} domain registration has expired.`,
+            title: `${arg.monitorName} domain check failed`,
+            description: `${arg.monitorName} domain registration has expired, or its registration data could not be retrieved.`,
             alertSeverityId: arg.alertSeverityId,
             autoResolveAlert: true,
             id: ObjectID.generate().toString(),
             onCallPolicyIds: [],
           },
         ],
-        name: `Check if ${arg.monitorName} domain is expired`,
-        description: `This criteria checks if the ${arg.monitorName} domain registration has expired`,
+        name: `Check if ${arg.monitorName} domain check failed`,
+        description: `This criteria checks if the ${arg.monitorName} domain registration has expired or could not be read`,
       };
     }
 

package/Types/Monitor/MonitorMetricType.ts

@@ -24,6 +24,14 @@ enum MonitorMetricType {
   TimeToFirstByte = "oneuptime.monitor.http.time.to.first.byte",
   DownloadTime = "oneuptime.monitor.http.download.time",
 
+  /*
+   * Port-monitor connection phases. These intentionally use a Port-specific
+   * namespace instead of the HTTP phase metrics above: Port TCP timing can
+   * include automatic address-family fallback and has no HTTP request phase.
+   */
+  PortDnsLookupTime = "oneuptime.monitor.port.dns.lookup.time",
+  PortTcpConnectTime = "oneuptime.monitor.port.tcp.connect.time",
+
   /*
    * Per-interface SNMP metrics. Emitted when interface monitoring is enabled
    * on an SNMP monitor; one series per interface (interfaceName attribute).

package/Types/Monitor/MonitorStep.ts

@@ -1144,8 +1144,17 @@ export default class MonitorStep extends DatabaseProperty {
       dnsMonitor: json["dnsMonitor"]
         ? (json["dnsMonitor"] as JSONObject)
         : undefined,
+      /*
+       * Normalized rather than passed through raw: steps saved before the
+       * lookupMethod option existed carry no such key, and the probe would
+       * otherwise receive a config that does not satisfy its own type.
+       */
       domainMonitor: json["domainMonitor"]
-        ? (json["domainMonitor"] as JSONObject)
+        ? MonitorStepDomainMonitorUtil.toJSON(
+            MonitorStepDomainMonitorUtil.fromJSON(
+              json["domainMonitor"] as JSONObject,
+            ),
+          )
         : undefined,
       dnssecMonitor: json["dnssecMonitor"]
         ? (json["dnssecMonitor"] as JSONObject)

package/Types/Monitor/MonitorStepDomainMonitor.ts

@@ -1,7 +1,9 @@
 import { JSONObject } from "../JSON";
+import DomainLookupMethod from "./DomainMonitor/DomainLookupMethod";
 
 export default interface MonitorStepDomainMonitor {
   domainName: string;
+  lookupMethod: DomainLookupMethod;
   timeout: number;
   retries: number;
 }
@@ -10,6 +12,7 @@ export class MonitorStepDomainMonitorUtil {
   public static getDefault(): MonitorStepDomainMonitor {
     return {
       domainName: "",
+      lookupMethod: DomainLookupMethod.Auto,
       timeout: 10000,
       retries: 3,
     };
@@ -18,6 +21,13 @@ export class MonitorStepDomainMonitorUtil {
   public static fromJSON(json: JSONObject): MonitorStepDomainMonitor {
     return {
       domainName: (json["domainName"] as string) || "",
+      /*
+       * Monitors saved before RDAP support existed carry no lookupMethod at
+       * all, and Auto is the behaviour they should get.
+       */
+      lookupMethod: MonitorStepDomainMonitorUtil.parseLookupMethod(
+        json["lookupMethod"],
+      ),
       timeout: (json["timeout"] as number) || 10000,
       retries: (json["retries"] as number) || 3,
     };
@@ -26,8 +36,19 @@ export class MonitorStepDomainMonitorUtil {
   public static toJSON(monitor: MonitorStepDomainMonitor): JSONObject {
     return {
       domainName: monitor.domainName,
+      lookupMethod: monitor.lookupMethod,
       timeout: monitor.timeout,
       retries: monitor.retries,
     };
   }
+
+  public static parseLookupMethod(value: unknown): DomainLookupMethod {
+    const values: Array<string> = Object.values(DomainLookupMethod);
+
+    if (typeof value === "string" && values.includes(value)) {
+      return value as DomainLookupMethod;
+    }
+
+    return DomainLookupMethod.Auto;
+  }
 }

package/Types/Monitor/PortMonitor/PortMonitorTimings.ts

@@ -0,0 +1,10 @@
+/*
+ * Per-phase breakdown of a Port monitor connection, in milliseconds. DNS is
+ * absent when the destination is already an IP address. Fields are optional
+ * so partial timing evidence can be represented when a connection fails.
+ */
+export default interface PortMonitorTimings {
+  dnsLookupInMs?: number | undefined;
+  tcpConnectInMs?: number | undefined;
+  totalConnectionInMs?: number | undefined;
+}

package/Types/Password.ts

@@ -0,0 +1,64 @@
+/*
+ * The password rules, in one place, so the form that collects a password and
+ * the endpoint that stores it cannot disagree about what is acceptable.
+ *
+ * Every password form in OneUptime has historically carried its own inline
+ * `minLength: 6`, and no server-side check existed at all -- the browser was
+ * the only thing enforcing it. That is fine right up until a password arrives
+ * from somewhere that is not the browser, which is exactly what an admin API
+ * is. These constants and `getPasswordValidationError` live in Common/Types
+ * (not Common/Server) precisely so the browser can import them too.
+ */
+
+/*
+ * Six is the number every existing OneUptime password form already enforces
+ * (Accounts sign-up, Accounts reset-password, the user profile, the status
+ * page). It is stated here rather than raised so that adopting this module
+ * cannot lock out anyone whose current password was accepted under the old
+ * inline rule.
+ */
+export const MINIMUM_PASSWORD_LENGTH: number = 6;
+
+/*
+ * An upper bound, so a caller cannot hand the hasher an arbitrarily large
+ * string. It is not a security property -- scrypt's cost is set by N/r/p, not
+ * by input length -- it just keeps a pathological request from becoming work.
+ * 100 is far above any password a person types and far below anything that
+ * matters.
+ */
+export const MAXIMUM_PASSWORD_LENGTH: number = 100;
+
+/**
+ * Why this password is unacceptable, or null if it is fine.
+ *
+ * Returns a message rather than throwing so the same function can back a
+ * browser-side form validator and a server-side guard -- the server wraps the
+ * message in the exception type it wants to return.
+ *
+ * Length is measured on the raw value, NOT a trimmed one: a password is a
+ * secret the user typed, and silently trimming it would store something other
+ * than what they entered and then fail to match it at login. A value that is
+ * *only* whitespace is rejected outright, though -- that is a mistake, not a
+ * password.
+ */
+export function getPasswordValidationError(
+  password: string | undefined | null,
+): string | null {
+  if (password === undefined || password === null || password === "") {
+    return "Password is required.";
+  }
+
+  if (password.trim().length === 0) {
+    return "Password cannot be blank.";
+  }
+
+  if (password.length < MINIMUM_PASSWORD_LENGTH) {
+    return `Password cannot be less than ${MINIMUM_PASSWORD_LENGTH} characters.`;
+  }
+
+  if (password.length > MAXIMUM_PASSWORD_LENGTH) {
+    return `Password cannot be more than ${MAXIMUM_PASSWORD_LENGTH} characters.`;
+  }
+
+  return null;
+}